/*!
 * opensocial-jquery templates 0.1.0
 * http://code.google.com/p/opensocial-jquery/
 *
 * Copyright(C) 2009 LEARNING RESOURCE LAB
 * http://friendfeed.com/nakajiman
 * http://hp.submit.ne.jp/d/16750/
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

if (!window.os) { // opensocial.template

  jQuery.fn.extend({
    
    // compile
    compile: function() {
      this.each(function() {
        var jscompile = parseInt(this.jscompile) || 0;
        if (jscompile == 0)
          os.compileNode_(this);
        this.jscompile = jscompile + 1;
      });
      return this;
    },

    // render
    render: function(data) {
      return this.compile().each(function() {
        jstProcess(os.createContext(data || {}), this);
      });
    }

  });

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 */

/**
 * @fileoverview Miscellaneous constants and functions referenced in
 * the main source files.
 *
 * @author Steffen Meschkat (mesch@google.com)
 */

//var MAPS_DEBUG = false;

//function log(msg) {}
function log(msg) {
  if (window.console) console.log(msg);
}

// String literals defined globally and not to be inlined. (IE6 perf)
/** @const */ var STRING_empty = '';

/** @const */ var CSS_display = 'display';
/** @const */ var CSS_position = 'position';

// Constants for possible values of the typeof operator.
var TYPE_boolean = 'boolean';
var TYPE_number = 'number';
var TYPE_object = 'object';
var TYPE_string = 'string';
var TYPE_function = 'function';
var TYPE_undefined = 'undefined';

/**
 * Wrapper for the eval() builtin function to evaluate expressions and
 * obtain their value. It wraps the expression in parentheses such
 * that object literals are really evaluated to objects. Without the
 * wrapping, they are evaluated as block, and create syntax
 * errors. Also protects against other syntax errors in the eval()ed
 * code and returns null if the eval throws an exception.
 *
 * @param {string} expr
 * @return {Object|null}
 */
//function jsEval(expr) {
//  try {
//    // NOTE: An alternative idiom would be:
//    //
//    //   eval('(' + expr + ')');
//    //
//    // Note that using the square brackets as below, "" evals to undefined.
//    // The alternative of using parentheses does not work when evaluating
//    // function literals in IE.
//    // e.g. eval("(function() {})") returns undefined, and not a function
//    // object, in IE.
//    return eval('[' + expr + '][0]');
//  } catch (e) {
//    log('EVAL FAILED ' + expr + ': ' + e);
//    return null;
//  }
//}

function jsLength(obj) {
  return obj.length;
}

//function assert(obj) {}

/**
 * Copies all properties from second object to the first.  Modifies to.
 *
 * @param {Object} to  The target object.
 * @param {Object} from  The source object.
 */
function copyProperties(to, from) {
  for (var p in from) {
    to[p] = from[p];
  }
}

/**
 * @param {Object|null|undefined} value The possible value to use.
 * @param {Object} defaultValue The default if the value is not set.
 * @return {Object} The value, if it is
 * defined and not null; otherwise the default
 */
function getDefaultObject(value, defaultValue) {
  if (typeof value != TYPE_undefined && value != null) {
    return /** @type Object */(value);
  } else {
    return defaultValue;
  }
}

/**
 * Detect if an object looks like an Array.
 * Note that instanceof Array is not robust; for example an Array
 * created in another iframe fails instanceof Array.
 * @param {Object|null} value Object to interrogate
 * @return {boolean} Is the object an array?
 */
function isArray(value) {
  return value != null &&
      typeof value == TYPE_object &&
      typeof value.length == TYPE_number;
}

/**
 * Finds a slice of an array.
 *
 * @param {Array} array  Array to be sliced.
 * @param {number} start  The start of the slice.
 * @param {number} opt_end  The end of the slice (optional).
 * @return {Array} array  The slice of the array from start to end.
 */
function arraySlice(array, start, opt_end) {
  // Use
  //   return Function.prototype.call.apply(Array.prototype.slice, arguments);
  // instead of the simpler
  //   return Array.prototype.slice.call(array, start, opt_end);
  // here because of a bug in the FF and IE implementations of
  // Array.prototype.slice which causes this function to return an empty list
  // if opt_end is not provided.
  return Function.prototype.call.apply(Array.prototype.slice, arguments);
}

/**
 * Jscompiler wrapper for parseInt() with base 10.
 *
 * @param {string} s string repersentation of a number.
 *
 * @return {number} The integer contained in s, converted on base 10.
 */
function parseInt10(s) {
  return parseInt(s, 10);
}

/**
 * Clears the array by setting the length property to 0. This usually
 * works, and if it should turn out not to work everywhere, here would
 * be the place to implement the browser specific workaround.
 *
 * @param {Array} array  Array to be cleared.
 */
function arrayClear(array) {
  array.length = 0;
}

/**
 * Prebinds "this" within the given method to an object, but ignores all 
 * arguments passed to the resulting function.
 * I.e. var_args are all the arguments that method is invoked with when
 * invoking the bound function.
 *
 * @param {Object|null} object  The object that the method call targets.
 * @param {Function} method  The target method.
 * @return {Function}  Method with the target object bound to it and curried by
 *                     the provided arguments.
 */
function bindFully(object, method, var_args) {
  var args = arraySlice(arguments, 2);
  return function() {
    return method.apply(object, args);
  }
}

// Based on <http://www.w3.org/TR/2000/ REC-DOM-Level-2-Core-20001113/
// core.html#ID-1950641247>.
var DOM_ELEMENT_NODE = 1;
var DOM_ATTRIBUTE_NODE = 2;
var DOM_TEXT_NODE = 3;
var DOM_CDATA_SECTION_NODE = 4;
var DOM_ENTITY_REFERENCE_NODE = 5;
var DOM_ENTITY_NODE = 6;
var DOM_PROCESSING_INSTRUCTION_NODE = 7;
var DOM_COMMENT_NODE = 8;
var DOM_DOCUMENT_NODE = 9;
var DOM_DOCUMENT_TYPE_NODE = 10;
var DOM_DOCUMENT_FRAGMENT_NODE = 11;
var DOM_NOTATION_NODE = 12;

function domGetElementById(document, id) {
  return document.getElementById(id);
}

/**
 * Creates a new node in the given document
 *
 * @param {Document} doc  Target document.
 * @param {string} name  Name of new element (i.e. the tag name)..
 * @return {Element}  Newly constructed element.
 */
function domCreateElement(doc, name) {
  return doc.createElement(name);
}

/**
 * Traverses the element nodes in the DOM section underneath the given
 * node and invokes the given callback as a method on every element
 * node encountered.
 *
 * @param {Element} node  Parent element of the subtree to traverse.
 * @param {Function} callback  Called on each node in the traversal.
 */
function domTraverseElements(node, callback) {
  var traverser = new DomTraverser(callback);
  traverser.run(node);
}

/**
 * A class to hold state for a dom traversal.
 * @param {Function} callback  Called on each node in the traversal.
 * @constructor
 * @class
 */
function DomTraverser(callback) {
  this.callback_ = callback;
}

/**
 * Processes the dom tree in breadth-first order.
 * @param {Element} root  The root node of the traversal.
 */
DomTraverser.prototype.run = function(root) {
  var me = this;
  me.queue_ = [ root ];
  while (jsLength(me.queue_)) {
    me.process_(me.queue_.shift());
  }
}

/**
 * Processes a single node.
 * @param {Element} node  The current node of the traversal.
 */
DomTraverser.prototype.process_ = function(node) {
  var me = this;

  me.callback_(node);

  for (var c = node.firstChild; c; c = c.nextSibling) {
    if (c.nodeType == DOM_ELEMENT_NODE) {
      me.queue_.push(c);
    }
  }
}

/**
 * Get an attribute from the DOM.  Simple redirect, exists to compress code.
 *
 * @param {Element} node  Element to interrogate.
 * @param {string} name  Name of parameter to extract.
 * @return {string|null}  Resulting attribute.
 */
function domGetAttribute(node, name) {
  return node.getAttribute(name);
  // NOTE: Neither in IE nor in Firefox, HTML DOM attributes
  // implement namespaces. All items in the attribute collection have
  // null localName and namespaceURI attribute values. In IE, we even
  // encounter DIV elements that don't implement the method
  // getAttributeNS().
}

/**
 * Set an attribute in the DOM.  Simple redirect to compress code.
 *
 * @param {Element} node  Element to interrogate.
 * @param {string} name  Name of parameter to set.
 * @param {string|number} value  Set attribute to this value.
 */
function domSetAttribute(node, name, value) {
  node.setAttribute(name, value);
}

/**
 * Remove an attribute from the DOM.  Simple redirect to compress code.
 *
 * @param {Element} node  Element to interrogate.
 * @param {string} name  Name of parameter to remove.
 */
function domRemoveAttribute(node, name) {
  node.removeAttribute(name);
}

/**
 * Clone a node in the DOM.
 *
 * @param {Node} node  Node to clone.
 * @return {Node}  Cloned node.
 */
function domCloneNode(node) {
  return node.cloneNode(true);
  // NOTE: we never so far wanted to use cloneNode(false),
  // hence the default.
}

/**
 * Clone a element in the DOM.
 *
 * @param {Element} element  Element to clone.
 * @return {Element}  Cloned element.
 */
function domCloneElement(element) {
  return /** @type {Element} */(domCloneNode(element));
}

/**
 * Returns the document owner of the given element. In particular,
 * returns window.document if node is null or the browser does not
 * support ownerDocument.  If the node is a document itself, returns
 * itself.
 *
 * @param {Node|null|undefined} node  The node whose ownerDocument is required.
 * @returns {Document}  The owner document or window.document if unsupported.
 */
function ownerDocument(node) {
  if (!node) {
    return document;
  } else if (node.nodeType == DOM_DOCUMENT_NODE) {
    return /** @type Document */(node);
  } else {
    return node.ownerDocument || document;
  }
}

/**
 * Creates a new text node in the given document.
 *
 * @param {Document} doc  Target document.
 * @param {string} text  Text composing new text node.
 * @return {Text}  Newly constructed text node.
 */
function domCreateTextNode(doc, text) {
  return doc.createTextNode(text);
}

/**
 * Appends a new child to the specified (parent) node.
 *
 * @param {Element} node  Parent element.
 * @param {Node} child  Child node to append.
 * @return {Node}  Newly appended node.
 */
function domAppendChild(node, child) {
  return node.appendChild(child);
}

/**
 * Sets display to default.
 *
 * @param {Element} node  The dom element to manipulate.
 */
function displayDefault(node) {
  node.style[CSS_display] = '';
}

/**
 * Sets display to none. Doing this as a function saves a few bytes for
 * the 'style.display' property and the 'none' literal.
 *
 * @param {Element} node  The dom element to manipulate.
 */
function displayNone(node) {
  node.style[CSS_display] = 'none';
}


/**
 * Sets position style attribute to absolute.
 *
 * @param {Element} node  The dom element to manipulate.
 */
function positionAbsolute(node) {
  node.style[CSS_position] = 'absolute';
}

/**
 * Inserts a new child before a given sibling.
 *
 * @param {Node} newChild  Node to insert.
 * @param {Node} oldChild  Sibling node.
 * @return {Node}  Reference to new child.
 */
function domInsertBefore(newChild, oldChild) {
  return oldChild.parentNode.insertBefore(newChild, oldChild);
}

/**
 * Replaces an old child node with a new child node.
 *
 * @param {Node} newChild  New child to append.
 * @param {Node} oldChild  Old child to remove.
 * @return {Node}  Replaced node.
 */
function domReplaceChild(newChild, oldChild) {
  return oldChild.parentNode.replaceChild(newChild, oldChild);
}

/**
 * Removes a node from the DOM.
 *
 * @param {Node} node  The node to remove.
 * @return {Node}  The removed node.
 */
function domRemoveNode(node) {
  return domRemoveChild(node.parentNode, node);
}

/**
 * Remove a child from the specified (parent) node.
 *
 * @param {Element} node  Parent element.
 * @param {Node} child  Child node to remove.
 * @return {Node}  Removed node.
 */
function domRemoveChild(node, child) {
  return node.removeChild(child);
}

/**
 * Trim whitespace from begin and end of string.
 *
 * @see testStringTrim();
 *
 * @param {string} str  Input string.
 * @return {string}  Trimmed string.
 */
function stringTrim(str) {
  return stringTrimRight(stringTrimLeft(str));
}

/**
 * Trim whitespace from beginning of string.
 *
 * @see testStringTrimLeft();
 *
 * @param {string} str  Input string.
 * @return {string}  Trimmed string.
 */
function stringTrimLeft(str) {
  return str.replace(/^\s+/, "");
}

/**
 * Trim whitespace from end of string.
 *
 * @see testStringTrimRight();
 *
 * @param {string} str  Input string.
 * @return {string}  Trimmed string.
  */
function stringTrimRight(str) {
  return str.replace(/\s+$/, "");
}

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 */

/**
 * Author: Steffen Meschkat <mesch@google.com>
 *
 * @fileoverview This class is used to evaluate expressions in a local
 * context. Used by JstProcessor.
 */

/**
 * Names of special variables defined by the jstemplate evaluation
 * context. These can be used in js expression in jstemplate
 * attributes.
 */
var VAR_index = 'Index';
var VAR_count = 'Count';
var VAR_this = '$this';
var VAR_context = '$context';
var VAR_top = '$top';
var VAR_loop = '$loop';

/**
 * The name of the global variable which holds the value to be returned if
 * context evaluation results in an error. 
 * Use JsEvalContext.setGlobal(GLOB_default, value) to set this.
 */
var GLOB_default = '$default';

/**
 * Un-inlined literals, to avoid object creation in IE6. TODO:
 * So far, these are only used here, but we could use them thoughout
 * the code and thus move them to constants.js.
 */
var CHAR_colon = ':';
var REGEXP_semicolon = /\s*;\s*/;

/**
 * See constructor_()
 * @param {Object|null} opt_data
 * @param {Object} opt_parent
 * @constructor
 */
function JsEvalContext(opt_data, opt_parent) {
  this.constructor_.apply(this, arguments);
}

/**
 * Context for processing a jstemplate. The context contains a context
 * object, whose properties can be referred to in jstemplate
 * expressions, and it holds the locally defined variables.
 *
 * @param {Object|null} opt_data The context object. Null if no context.
 *
 * @param {Object} opt_parent The parent context, from which local
 * variables are inherited. Normally the context object of the parent
 * context is the object whose property the parent object is. Null for the
 * context of the root object.
 */
JsEvalContext.prototype.constructor_ = function(opt_data, opt_parent) {
  var me = this;

  /**
   * The context for variable definitions in which the jstemplate
   * expressions are evaluated. Other than for the local context,
   * which replaces the parent context, variable definitions of the
   * parent are inherited. The special variable $this points to data_.
   *
   * If this instance is recycled from the cache, then the property is
   * already initialized.
   *
   * @type {Object}
   */
  if (!me.vars_) {
    me.vars_ = {};
  }
  if (opt_parent) {
    // If there is a parent node, inherit local variables from the
    // parent.
    copyProperties(me.vars_, opt_parent.vars_);
  } else {
    // If a root node, inherit global symbols. Since every parent
    // chain has a root with no parent, global variables will be
    // present in the case above too. This means that globals can be
    // overridden by locals, as it should be.
    copyProperties(me.vars_, JsEvalContext.globals_);
  }

  /**
   * The current context object is assigned to the special variable
   * $this so it is possible to use it in expressions.
   * @type Object
   */
  me.vars_[VAR_this] = opt_data;

  /**
   * The entire context structure is exposed as a variable so it can be
   * passed to javascript invocations through jseval.
   */
  me.vars_[VAR_context] = me;

  /**
   * The local context of the input data in which the jstemplate
   * expressions are evaluated. Notice that this is usually an Object,
   * but it can also be a scalar value (and then still the expression
   * $this can be used to refer to it). Notice this can even be value,
   * undefined or null. Hence, we have to protect jsexec() from using
   * undefined or null, yet we want $this to reflect the true value of
   * the current context. Thus we assign the original value to $this,
   * above, but for the expression context we replace null and
   * undefined by the empty string.
   *
   * @type {Object|null}
   */
  me.data_ = getDefaultObject(opt_data, STRING_empty);

  if (!opt_parent) {
    // If this is a top-level context, create a variable reference to the data
    // to allow for  accessing top-level properties of the original context
    // data from child contexts.
    me.vars_[VAR_top] = me.data_;
  }
};

/**
 * A map of globally defined symbols. Every instance of JsExprContext
 * inherits them in its vars_.
 * @type Object
 */
JsEvalContext.globals_ = {}

/**
 * Sets a global symbol. It will be available like a variable in every
 * JsEvalContext instance. This is intended mainly to register
 * immutable global objects, such as functions, at load time, and not
 * to add global data at runtime. I.e. the same objections as to
 * global variables in general apply also here. (Hence the name
 * "global", and not "global var".)
 * @param {string} name
 * @param {Object|null} value
 */
JsEvalContext.setGlobal = function(name, value) {
  JsEvalContext.globals_[name] = value;
};

/**
 * Set the default value to be returned if context evaluation results in an 
 * error. (This can occur if a non-existent value was requested). 
 */
JsEvalContext.setGlobal(GLOB_default, null);

/**
 * A cache to reuse JsEvalContext instances. (IE6 perf)
 *
 * @type Array.<JsEvalContext>
 */
JsEvalContext.recycledInstances_ = [];

/**
 * A factory to create a JsEvalContext instance, possibly reusing
 * one from recycledInstances_. (IE6 perf)
 *
 * @param {Object} opt_data
 * @param {JsEvalContext} opt_parent
 * @return {JsEvalContext}
 */
JsEvalContext.create = function(opt_data, opt_parent) {
  if (jsLength(JsEvalContext.recycledInstances_) > 0) {
    var instance = JsEvalContext.recycledInstances_.pop();
    JsEvalContext.call(instance, opt_data, opt_parent);
    return instance;
  } else {
    return new JsEvalContext(opt_data, opt_parent);
  }
};

/**
 * Recycle a used JsEvalContext instance, so we can avoid creating one
 * the next time we need one. (IE6 perf)
 *
 * @param {JsEvalContext} instance
 */
JsEvalContext.recycle = function(instance) {
  for (var i in instance.vars_) {
    // NOTE: We avoid object creation here. (IE6 perf)
    delete instance.vars_[i];
  }
  instance.data_ = null;
  JsEvalContext.recycledInstances_.push(instance);
};

/**
 * Executes a function created using jsEvalToFunction() in the context
 * of vars, data, and template.
 *
 * @param {Function} exprFunction A javascript function created from
 * a jstemplate attribute value.
 *
 * @param {Element} template DOM node of the template.
 *
 * @return {Object|null} The value of the expression from which
 * exprFunction was created in the current js expression context and
 * the context of template.
 */
JsEvalContext.prototype.jsexec = function(exprFunction, template) {
  try {
    return exprFunction.call(template, this.vars_, this.data_);
  } catch (e) {
    log('jsexec EXCEPTION: ' + e + ' at ' + template +
        ' with ' + exprFunction);
    return JsEvalContext.globals_[GLOB_default];
  }
};

/**
 * Clones the current context for a new context object. The cloned
 * context has the data object as its context object and the current
 * context as its parent context. It also sets the $index variable to
 * the given value. This value usually is the position of the data
 * object in a list for which a template is instantiated multiply.
 *
 * @param {Object} data The new context object.
 *
 * @param {number} index Position of the new context when multiply
 * instantiated. (See implementation of jstSelect().)
 * 
 * @param {number} count The total number of contexts that were multiply
 * instantiated. (See implementation of jstSelect().)
 *
 * @return {JsEvalContext}
 */
JsEvalContext.prototype.clone = function(data, index, count) {
  var ret = JsEvalContext.create(data, this);
  if (typeof(index) == 'number' || typeof(count) == 'number') {
    var loopContext = {};
    loopContext[VAR_index] = index;
    loopContext[VAR_count] = count;
    ret.setVariable(VAR_loop, loopContext);
  }
  return ret;
};

/**
 * Binds a local variable to the given value. If set from jstemplate
 * jsvalue expressions, variable names must start with $, but in the
 * API they only have to be valid javascript identifier.
 *
 * @param {string} name
 *
 * @param {Object?} value
 */
JsEvalContext.prototype.setVariable = function(name, value) {
  this.vars_[name] = value;
};

/**
 * Returns the value bound to the local variable of the given name, or
 * undefined if it wasn't set. There is no way to distinguish a
 * variable that wasn't set from a variable that was set to
 * undefined. Used mostly for testing.
 *
 * @param {string} name
 *
 * @return {Object?} value
 */
JsEvalContext.prototype.getVariable = function(name) {
  return this.vars_[name];
};

/**
 * Evaluates a string expression within the scope of this context
 * and returns the result.
 *
 * @param {string} expr A javascript expression
 * @param {Element} opt_template An optional node to serve as "this"
 *
 * @return {Object?} value
 */
JsEvalContext.prototype.evalExpression = function(expr, opt_template) {
  var exprFunction = jsEvalToFunction(expr);
  return this.jsexec(exprFunction, opt_template);
};

/**
 * Uninlined string literals for jsEvalToFunction() (IE6 perf).
 */
var STRING_a = 'a_';
var STRING_b = 'b_';
var STRING_with = 'with (a_) with (b_) return ';

/**
 * Cache for jsEvalToFunction results.
 * @type Object
 */
JsEvalContext.evalToFunctionCache_ = {};

/**
 * Evaluates the given expression as the body of a function that takes
 * vars and data as arguments. Since the resulting function depends
 * only on expr, we cache the result so we save some Function
 * invocations, and some object creations in IE6.
 *
 * @param {string} expr A javascript expression.
 *
 * @return {Function} A function that returns the value of expr in the
 * context of vars and data.
 */
function jsEvalToFunction(expr) {
  if (!JsEvalContext.evalToFunctionCache_[expr]) {
    try {
      // NOTE: The Function constructor is faster than eval().
      JsEvalContext.evalToFunctionCache_[expr] =
        new Function(STRING_a, STRING_b, STRING_with + expr);
    } catch (e) {
      log('jsEvalToFunction (' + expr + ') EXCEPTION ' + e);
    }
  }
  return JsEvalContext.evalToFunctionCache_[expr];
}

/**
 * Evaluates the given expression to itself. This is meant to pass
 * through string attribute values.
 *
 * @param {string} expr
 *
 * @return {string}
 */
function jsEvalToSelf(expr) {
  return expr;
}

/**
 * Parses the value of the jsvalues attribute in jstemplates: splits
 * it up into a map of labels and expressions, and creates functions
 * from the expressions that are suitable for execution by
 * JsEvalContext.jsexec(). All that is returned as a flattened array
 * of pairs of a String and a Function.
 *
 * @param {string} expr
 *
 * @return {Array}
 */
function jsEvalToValues(expr) {
  // TODO: It is insufficient to split the values by simply
  // finding semi-colons, as the semi-colon may be part of a string
  // constant or escaped.
  var ret = [];
  var values = expr.split(REGEXP_semicolon);
  for (var i = 0, I = jsLength(values); i < I; ++i) {
    var colon = values[i].indexOf(CHAR_colon);
    if (colon < 0) {
      continue;
    }
    var label = stringTrim(values[i].substr(0, colon));
    var value = jsEvalToFunction(values[i].substr(colon + 1));
    ret.push(label, value);
  }
  return ret;
}

/**
 * Parses the value of the jseval attribute of jstemplates: splits it
 * up into a list of expressions, and creates functions from the
 * expressions that are suitable for execution by
 * JsEvalContext.jsexec(). All that is returned as an Array of
 * Function.
 *
 * @param {string} expr
 *
 * @return {Array.<Function>}
 */
function jsEvalToExpressions(expr) {
  var ret = [];
  var values = expr.split(REGEXP_semicolon);
  for (var i = 0, I = jsLength(values); i < I; ++i) {
    if (values[i]) {
      var value = jsEvalToFunction(values[i]);
      ret.push(value);
    }
  }
  return ret;
}

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 */

/**
 * Author: Steffen Meschkat <mesch@google.com>
 *
 * @fileoverview A simple formatter to project JavaScript data into
 * HTML templates. The template is edited in place. I.e. in order to
 * instantiate a template, clone it from the DOM first, and then
 * process the cloned template. This allows for updating of templates:
 * If the templates is processed again, changed values are merely
 * updated.
 *
 * NOTE: IE DOM doesn't have importNode().
 *
 * NOTE: The property name "length" must not be used in input
 * data, see comment in jstSelect_().
 */

/**
 * Names of jstemplate attributes. These attributes are attached to
 * normal HTML elements and bind expression context data to the HTML
 * fragment that is used as template.
 */
var ATT_select = 'jsselect';
var ATT_instance = 'jsinstance';
var ATT_display = 'jsdisplay';
var ATT_values = 'jsvalues';
var ATT_vars = 'jsvars';
var ATT_eval = 'jseval';
var ATT_transclude = 'transclude';
var ATT_content = 'jscontent';
var ATT_skip = 'jsskip';
var ATT_innerselect = 'jsinnerselect';

/**
 * Name of the attribute that caches a reference to the parsed
 * template processing attribute values on a template node.
 */
var ATT_jstcache = 'jstcache';

/**
 * Name of the property that caches the parsed template processing
 * attribute values on a template node.
 */
var PROP_jstcache = '__jstcache';

/**
 * ID of the element that contains dynamically loaded jstemplates.
 */
var STRING_jsts = 'jsts';

/**
 * Un-inlined string literals, to avoid object creation in
 * IE6.
 */
var CHAR_asterisk = '*';
var CHAR_dollar = '$';
var CHAR_period = '.';
var CHAR_ampersand = '&';
var STRING_div = 'div';
var STRING_id = 'id';
var STRING_asteriskzero = '*0';
var STRING_zero = '0';

/**
 * HTML template processor. Data values are bound to HTML templates
 * using the attributes transclude, jsselect, jsdisplay, jscontent,
 * jsvalues. The template is modifed in place. The values of those
 * attributes are JavaScript expressions that are evaluated in the
 * context of the data object fragment.
 *
 * @param {JsEvalContext} context Context created from the input data
 * object.
 *
 * @param {Element} template DOM node of the template. This will be
 * processed in place. After processing, it will still be a valid
 * template that, if processed again with the same data, will remain
 * unchanged.
 *
 * @param {boolean} opt_debugging Optional flag to collect debugging
 *     information while processing the template.  Only takes effect
 *     in MAPS_DEBUG.
 */
function jstProcess(context, template, opt_debugging) {
  var processor = new JstProcessor;
//  if (MAPS_DEBUG && opt_debugging) {
//    processor.setDebugging(opt_debugging);
//  }
  JstProcessor.prepareTemplate_(template);

  /**
   * Caches the document of the template node, so we don't have to
   * access it through ownerDocument.
   * @type Document
   */
  processor.document_ = ownerDocument(template);

  processor.run_(bindFully(processor, processor.jstProcessOuter_,
                           context, template));
//  if (MAPS_DEBUG && opt_debugging) {
//    log('jstProcess:' + '\n' + processor.getLogs().join('\n'));
//  }
}

/**
 * Internal class used by jstemplates to maintain context.  This is
 * necessary to process deep templates in Safari which has a
 * relatively shallow maximum recursion depth of 100.
 * @class
 * @constructor
 */
function JstProcessor() {
//  if (MAPS_DEBUG) {
//    /**
//     * An array of logging messages.  These are collected during processing
//     * and dumped to the console at the end.
//     * @type Array.<string>
//     */
//    this.logs_ = [];
//  }
}

/**
 * Counter to generate node ids. These ids will be stored in
 * ATT_jstcache and be used to lookup the preprocessed js attributes
 * from the jstcache_. The id is stored in an attribute so it
 * suvives cloneNode() and thus cloned template nodes can share the
 * same cache entry.
 * @type number
 */
JstProcessor.jstid_ = 0;

/**
 * Map from jstid to processed js attributes.
 * @type Object
 */
JstProcessor.jstcache_ = {};

/**
 * The neutral cache entry. Used for all nodes that don't have any
 * jst attributes. We still set the jsid attribute on those nodes so
 * we can avoid to look again for all the other jst attributes that
 * aren't there. Remember: not only the processing of the js
 * attribute values is expensive and we thus want to cache it. The
 * access to the attributes on the Node in the first place is
 * expensive too.
 */
JstProcessor.jstcache_[0] = {};

/**
 * Map from concatenated attribute string to jstid.
 * The key is the concatenation of all jst atributes found on a node
 * formatted as "name1=value1&name2=value2&...", in the order defined by
 * JST_ATTRIBUTES. The value is the id of the jstcache_ entry that can
 * be used for this node. This allows the reuse of cache entries in cases
 * when a cached entry already exists for a given combination of attribute
 * values. (For example when two different nodes in a template share the same
 * JST attributes.)
 * @type Object
 */
JstProcessor.jstcacheattributes_ = {};

/**
 * Map for storing temporary attribute values in prepareNode_() so they don't
 * have to be retrieved twice. (IE6 perf)
 * @type Object
 */
JstProcessor.attributeValues_ = {};

/**
 * A list for storing non-empty attributes found on a node in prepareNode_().
 * The array is global since it can be reused - this way there is no need to
 * construct a new array object for each invocation. (IE6 perf)
 * @type Array
 */
JstProcessor.attributeList_ = [];

/**
 * Prepares the template: preprocesses all jstemplate attributes.
 *
 * @param {Element} template
 */
JstProcessor.prepareTemplate_ = function(template) {
  if (!template[PROP_jstcache]) {
    domTraverseElements(template, function(node) {
      JstProcessor.prepareNode_(node);
    });
  }
};

/**
 * A list of attributes we use to specify jst processing instructions,
 * and the functions used to parse their values.
 *
 * @type Array.<Array>
 */
var JST_ATTRIBUTES = [
    [ ATT_select, jsEvalToFunction ],
    [ ATT_display, jsEvalToFunction ],
    [ ATT_values, jsEvalToValues ],
    [ ATT_vars, jsEvalToValues ],
    [ ATT_eval, jsEvalToExpressions ],
    [ ATT_transclude, jsEvalToSelf ],
    [ ATT_content, jsEvalToFunction ],
    [ ATT_skip, jsEvalToFunction ],
    [ ATT_innerselect, jsEvalToFunction ]
];

/**
 * Prepares a single node: preprocesses all template attributes of the
 * node, and if there are any, assigns a jsid attribute and stores the
 * preprocessed attributes under the jsid in the jstcache.
 *
 * @param {Element} node
 *
 * @return {Object} The jstcache entry. The processed jst attributes
 * are properties of this object. If the node has no jst attributes,
 * returns an object with no properties (the jscache_[0] entry).
 */
JstProcessor.prepareNode_ = function(node) {
  // If the node already has a cache property, return it.
  if (node[PROP_jstcache]) {
    return node[PROP_jstcache];
  }

  // If it is not found, we always set the PROP_jstcache property on the node.
  // Accessing the property is faster than executing getAttribute(). If we
  // don't find the property on a node that was cloned in jstSelect_(), we
  // will fall back to check for the attribute and set the property
  // from cache.

  // If the node has an attribute indexing a cache object, set it as a property
  // and return it.
  var jstid = domGetAttribute(node, ATT_jstcache);
  if (jstid != null) {
    return node[PROP_jstcache] = JstProcessor.jstcache_[jstid];
  }

  var attributeValues = JstProcessor.attributeValues_;
  var attributeList = JstProcessor.attributeList_;
  attributeList.length = 0;

  // Look for interesting attributes.
  for (var i = 0, I = jsLength(JST_ATTRIBUTES); i < I; ++i) {
    var name = JST_ATTRIBUTES[i][0];
    var value = domGetAttribute(node, name);
    attributeValues[name] = value;
    if (value != null) {
      attributeList.push(name + "=" + value);
    }
  }

  // If none found, mark this node to prevent further inspection, and return
  // an empty cache object.
  if (attributeList.length == 0) {
    domSetAttribute(node, ATT_jstcache, STRING_zero);
    return node[PROP_jstcache] = JstProcessor.jstcache_[0];
  }

  // If we already have a cache object corresponding to these attributes,
  // annotate the node with it, and return it.
  var attstring = attributeList.join(CHAR_ampersand);
  if (jstid = JstProcessor.jstcacheattributes_[attstring]) {
    domSetAttribute(node, ATT_jstcache, jstid);
    return node[PROP_jstcache] = JstProcessor.jstcache_[jstid];
  }

  // Otherwise, build a new cache object.
  var jstcache = {};
  for (var i = 0, I = jsLength(JST_ATTRIBUTES); i < I; ++i) {
    var att = JST_ATTRIBUTES[i];
    var name = att[0];
    var parse = att[1];
    var value = attributeValues[name];
    if (value != null) {
      jstcache[name] = parse(value);
//      if (MAPS_DEBUG) {
//        jstcache.jstAttributeValues = jstcache.jstAttributeValues || {};
//        jstcache.jstAttributeValues[name] = value;
//      }
    }
  }

  jstid = STRING_empty + ++JstProcessor.jstid_;
  domSetAttribute(node, ATT_jstcache, jstid);
  JstProcessor.jstcache_[jstid] = jstcache;
  JstProcessor.jstcacheattributes_[attstring] = jstid;

  return node[PROP_jstcache] = jstcache;
};

/**
 * Runs the given function in our state machine.
 *
 * It's informative to view the set of all function calls as a tree:
 * - nodes are states
 * - edges are state transitions, implemented as calls to the pending
 *   functions in the stack.
 *   - pre-order function calls are downward edges (recursion into call).
 *   - post-order function calls are upward edges (return from call).
 * - leaves are nodes which do not recurse.
 * We represent the call tree as an array of array of calls, indexed as
 * stack[depth][index].  Here [depth] indexes into the call stack, and
 * [index] indexes into the call queue at that depth.  We require a call
 * queue so that a node may branch to more than one child
 * (which will be called serially), typically due to a loop structure.
 *
 * @param {Function} f The first function to run.
 */
JstProcessor.prototype.run_ = function(f) {
  var me = this;

  /**
   * A stack of queues of pre-order calls.
   * The inner arrays (constituent queues) are structured as
   * [ arg2, arg1, method, arg2, arg1, method, ...]
   * ie. a flattened array of methods with 2 arguments, in reverse order
   * for efficient push/pop.
   *
   * The outer array is a stack of such queues.
   *
   * @type Array.<Array>
   */
  var calls = me.calls_ = [];

  /**
   * The index into the queue for each depth. NOTE: Alternative would
   * be to maintain the queues in reverse order (popping off of the
   * end) but the repeated calls to .pop() consumed 90% of this
   * function's execution time.
   * @type Array.<number>
   */
  var queueIndices = me.queueIndices_ = [];

  /**
   * A pool of empty arrays.  Minimizes object allocation for IE6's benefit.
   * @type Array.<Array>
   */
  var arrayPool = me.arrayPool_ = [];

  f();
  var queue, queueIndex;
  var method, arg1, arg2;
  var temp;
  while (calls.length) {
    queue = calls[calls.length - 1];
    queueIndex = queueIndices[queueIndices.length - 1];
    if (queueIndex >= queue.length) {
      me.recycleArray_(calls.pop());
      queueIndices.pop();
      continue;
    }

    // Run the first function in the queue.
    method = queue[queueIndex++];
    arg1 = queue[queueIndex++];
    arg2 = queue[queueIndex++];
    queueIndices[queueIndices.length - 1] = queueIndex;
    method.call(me, arg1, arg2);
  }
};

/**
 * Pushes one or more functions onto the stack.  These will be run in sequence,
 * interspersed with any recursive calls that they make.
 *
 * This method takes ownership of the given array!
 *
 * @param {Array} args Array of method calls structured as
 *     [ method, arg1, arg2, method, arg1, arg2, ... ]
 */
JstProcessor.prototype.push_ = function(args) {
  this.calls_.push(args);
  this.queueIndices_.push(0);
};

/**
 * Enable/disable debugging.
 * @param {boolean} debugging New state
 */
//JstProcessor.prototype.setDebugging = function(debugging) {
//  if (MAPS_DEBUG) {
//    this.debugging_ = debugging;
//  }
//};

JstProcessor.prototype.createArray_ = function() {
  if (this.arrayPool_.length) {
    return this.arrayPool_.pop();
  } else {
    return [];
  }
};

JstProcessor.prototype.recycleArray_ = function(array) {
  arrayClear(array);
  this.arrayPool_.push(array);
};

/**
 * Implements internals of jstProcess. This processes the two
 * attributes transclude and jsselect, which replace or multiply
 * elements, hence the name "outer". The remainder of the attributes
 * is processed in jstProcessInner_(), below. That function
 * jsProcessInner_() only processes attributes that affect an existing
 * node, but doesn't create or destroy nodes, hence the name
 * "inner". jstProcessInner_() is called through jstSelect_() if there
 * is a jsselect attribute (possibly for newly created clones of the
 * current template node), or directly from here if there is none.
 *
 * @param {JsEvalContext} context
 *
 * @param {Element} template
 */
JstProcessor.prototype.jstProcessOuter_ = function(context, template) {
  var me = this;

  var jstAttributes = me.jstAttributes_(template);
//  if (MAPS_DEBUG && me.debugging_) {
//    me.logState_('Outer', template, jstAttributes.jstAttributeValues);
//  }

  var transclude = jstAttributes[ATT_transclude];
  if (transclude) {
    var tr = jstGetTemplate(transclude);
    if (tr) {
      domReplaceChild(tr, template);
      var call = me.createArray_();
      call.push(me.jstProcessOuter_, context, tr);
      me.push_(call);
    } else {
      domRemoveNode(template);
    }
    return;
  }

  var select = jstAttributes[ATT_select];
  if (select) {
    me.jstSelect_(context, template, select);
  } else {
    me.jstProcessInner_(context, template);
  }
};

/**
 * Implements internals of jstProcess. This processes all attributes
 * except transclude and jsselect. It is called either from
 * jstSelect_() for nodes that have a jsselect attribute so that the
 * jsselect attribute will not be processed again, or else directly
 * from jstProcessOuter_(). See the comment on jstProcessOuter_() for
 * an explanation of the name.
 *
 * @param {JsEvalContext} context
 *
 * @param {Element} template
 */
JstProcessor.prototype.jstProcessInner_ = function(context, template) {
  var me = this;

  var jstAttributes = me.jstAttributes_(template);
//  if (MAPS_DEBUG && me.debugging_) {
//    me.logState_('Inner', template, jstAttributes.jstAttributeValues);
//  }

  // NOTE: See NOTE on ATT_content why this is a separate
  // attribute, and not a special value in ATT_values.
  var display = jstAttributes[ATT_display];
  if (display) {
    var shouldDisplay = context.jsexec(display, template);
//    if (MAPS_DEBUG && me.debugging_) {
//      me.logs_.push(ATT_display + ': ' + shouldDisplay + '<br/>');
//    }
    if (!shouldDisplay) {
      displayNone(template);
      return;
    }
    displayDefault(template);
  }

  // NOTE: jsvars is evaluated before jsvalues, because it's
  // more useful to be able to use var values in attribute value
  // expressions than vice versa.
  var values = jstAttributes[ATT_vars];
  if (values) {
    me.jstVars_(context, template, values);
  }

  values = jstAttributes[ATT_values];
  if (values) {
    me.jstValues_(context, template, values);
  }

  // Evaluate expressions immediately. Useful for hooking callbacks
  // into jstemplates.
  //
  // NOTE: Evaluation order is sometimes significant, e.g. when
  // the expression evaluated in jseval relies on the values set in
  // jsvalues, so it needs to be evaluated *after*
  // jsvalues. TODO: This is quite arbitrary, it would be
  // better if this would have more necessity to it.
  var expressions = jstAttributes[ATT_eval];
  if (expressions) {
    for (var i = 0, I = jsLength(expressions); i < I; ++i) {
      context.jsexec(expressions[i], template);
    }
  }

  var skip = jstAttributes[ATT_skip];
  if (skip) {
    var shouldSkip = context.jsexec(skip, template);
//    if (MAPS_DEBUG && me.debugging_) {
//      me.logs_.push(ATT_skip + ': ' + shouldSkip + '<br/>');
//    }
    if (shouldSkip) return;
  }

  // NOTE: content is a separate attribute, instead of just a
  // special value mentioned in values, for two reasons: (1) it is
  // fairly common to have only mapped content, and writing
  // content="expr" is shorter than writing values="content:expr", and
  // (2) the presence of content actually terminates traversal, and we
  // need to check for that. Display is a separate attribute for a
  // reason similar to the second, in that its presence *may*
  // terminate traversal.
  var content = jstAttributes[ATT_content];
  if (content) {
    me.jstContent_(context, template, content);

  } else {
    // Newly generated children should be ignored, so we explicitly
    // store the children to be processed.
    var queue = me.createArray_();
    var ctx = null;
    for (var c = template.firstChild; c; c = c.nextSibling) {
      if (c.nodeType == DOM_ELEMENT_NODE) {
        // Construct a new context if needed, lazily.
        if (!ctx) {
          ctx = context; 
          var selectInner = jstAttributes[ATT_innerselect];
          if (selectInner && selectInner != VAR_this) {
            ctx = context.clone(context.jsexec(selectInner, template), 0, 0);
          }
        }
        queue.push(me.jstProcessOuter_, ctx, c);
      }
    }
    if (queue.length) me.push_(queue);
  }
};

/**
 * Implements the jsselect attribute: evalutes the value of the
 * jsselect attribute in the current context, with the current
 * variable bindings (see JsEvalContext.jseval()). If the value is an
 * array, the current template node is multiplied once for every
 * element in the array, with the array element being the context
 * object. If the array is empty, or the value is undefined, then the
 * current template node is dropped. If the value is not an array,
 * then it is just made the context object.
 *
 * @param {JsEvalContext} context The current evaluation context.
 *
 * @param {Element} template The currently processed node of the template.
 *
 * @param {Function} select The javascript expression to evaluate.
 *
 * @notypecheck FIXME(hmitchell): See OCL6434950. instance and value need
 * type checks.
 */
JstProcessor.prototype.jstSelect_ = function(context, template, select) {
  var me = this;

  var value = context.jsexec(select, template);

  // Enable reprocessing: if this template is reprocessed, then only
  // fill the section instance here. Otherwise do the cardinal
  // processing of a new template.
  var instance = domGetAttribute(template, ATT_instance);

  var instanceLast = false;
  if (instance) {
    if (instance.charAt(0) == CHAR_asterisk) {
      instance = parseInt10(instance.substr(1));
      instanceLast = true;
    } else {
      instance = parseInt10(/** @type string */(instance));
    }
  }

  // The expression value instanceof Array is occasionally false for
  // arrays, seen in Firefox. Thus we recognize an array as an object
  // which is not null that has a length property. Notice that this
  // also matches input data with a length property, so this property
  // name should be avoided in input data.
  var multiple = isArray(value);
  var count = multiple ? jsLength(value) : 1;
  var multipleEmpty = (multiple && count == 0);

  if (multiple) {
    if (multipleEmpty) {
      // For an empty array, keep the first template instance and mark
      // it last. Remove all other template instances.
      if (!instance) {
        domSetAttribute(template, ATT_instance, STRING_asteriskzero);
        displayNone(template);
      } else {
        domRemoveNode(template);
      }

    } else {
      displayDefault(template);
      // For a non empty array, create as many template instances as
      // are needed. If the template is first processed, as many
      // template instances are needed as there are values in the
      // array. If the template is reprocessed, new template instances
      // are only needed if there are more array values than template
      // instances. Those additional instances are created by
      // replicating the last template instance.
      //
      // When the template is first processed, there is no jsinstance
      // attribute. This is indicated by instance === null, except in
      // opera it is instance === "". Notice also that the === is
      // essential, because 0 == "", presumably via type coercion to
      // boolean.
      if (instance === null || instance === STRING_empty ||
          (instanceLast && instance < count - 1)) {
        // A queue of calls to push.
        var queue = me.createArray_();

        var instancesStart = instance || 0;
        var i, I, clone;
        for (i = instancesStart, I = count - 1; i < I; ++i) {
          var node = domCloneNode(template);
          domInsertBefore(node, template);

          jstSetInstance(/** @type Element */(node), value, i);
          clone = context.clone(value[i], i, count);

          queue.push(me.jstProcessInner_, clone, node,
                     JsEvalContext.recycle, clone, null);
                     
        }
        // Push the originally present template instance last to keep
        // the order aligned with the DOM order, because the newly
        // created template instances are inserted *before* the
        // original instance.
        jstSetInstance(template, value, i);
        clone = context.clone(value[i], i, count);
        queue.push(me.jstProcessInner_, clone, template,
                   JsEvalContext.recycle, clone, null);
        me.push_(queue);
      } else if (instance < count) {
        var v = value[instance];

        jstSetInstance(template, value, instance);
        var clone = context.clone(v, instance, count);
        var queue = me.createArray_();
        queue.push(me.jstProcessInner_, clone, template,
                   JsEvalContext.recycle, clone, null);
        me.push_(queue);
      } else {
        domRemoveNode(template);
      }
    }
  } else {
    if (value == null) {
      displayNone(template);
    } else {
      displayDefault(template);
      var clone = context.clone(value, 0, 1);
      var queue = me.createArray_();
      queue.push(me.jstProcessInner_, clone, template,
                 JsEvalContext.recycle, clone, null);
      me.push_(queue);
    }
  }
};

/**
 * Implements the jsvars attribute: evaluates each of the values and
 * assigns them to variables in the current context. Similar to
 * jsvalues, except that all values are treated as vars, independent
 * of their names.
 *
 * @param {JsEvalContext} context Current evaluation context.
 *
 * @param {Element} template Currently processed template node.
 *
 * @param {Array} values Processed value of the jsvalues attribute: a
 * flattened array of pairs. The second element in the pair is a
 * function that can be passed to jsexec() for evaluation in the
 * current jscontext, and the first element is the variable name that
 * the value returned by jsexec is assigned to.
 */
JstProcessor.prototype.jstVars_ = function(context, template, values) {
  for (var i = 0, I = jsLength(values); i < I; i += 2) {
    var label = values[i];
    var value = context.jsexec(values[i+1], template);
    context.setVariable(label, value);
  }
};

/**
 * Implements the jsvalues attribute: evaluates each of the values and
 * assigns them to variables in the current context (if the name
 * starts with '$', javascript properties of the current template node
 * (if the name starts with '.'), or DOM attributes of the current
 * template node (otherwise). Since DOM attribute values are always
 * strings, the value is coerced to string in the latter case,
 * otherwise it's the uncoerced javascript value.
 *
 * @param {JsEvalContext} context Current evaluation context.
 *
 * @param {Element} template Currently processed template node.
 *
 * @param {Array} values Processed value of the jsvalues attribute: a
 * flattened array of pairs. The second element in the pair is a
 * function that can be passed to jsexec() for evaluation in the
 * current jscontext, and the first element is the label that
 * determines where the value returned by jsexec is assigned to.
 */
JstProcessor.prototype.jstValues_ = function(context, template, values) {
  for (var i = 0, I = jsLength(values); i < I; i += 2) {
    var label = values[i];
    var value = context.jsexec(values[i+1], template);

    if (label.charAt(0) == CHAR_dollar) {
      // A jsvalues entry whose name starts with $ sets a local
      // variable.
      context.setVariable(label, value);

    } else if (label.charAt(0) == CHAR_period) {
      // A jsvalues entry whose name starts with . sets a property of
      // the current template node. The name may have further dot
      // separated components, which are translated into namespace
      // objects. This specifically allows to set properties on .style
      // using jsvalues. NOTE: Setting the style attribute has
      // no effect in IE and hence should not be done anyway.
      var nameSpaceLabel = label.substr(1).split(CHAR_period);
      var nameSpaceObject = template;
      var nameSpaceDepth = jsLength(nameSpaceLabel);
      for (var j = 0, J = nameSpaceDepth - 1; j < J; ++j) {
        var jLabel = nameSpaceLabel[j];
        if (!nameSpaceObject[jLabel]) {
          nameSpaceObject[jLabel] = {};
        }
        nameSpaceObject = nameSpaceObject[jLabel];
      }
      nameSpaceObject[nameSpaceLabel[nameSpaceDepth - 1]] = value;

    } else if (label) {
      // Any other jsvalues entry sets an attribute of the current
      // template node.
      if (typeof value == TYPE_boolean) {
        // Handle boolean values that are set as attributes specially,
        // according to the XML/HTML convention.
        if (value) {
//        domSetAttribute(template, label, label);
jQuery(template).attr(label, label);
        } else {
          domRemoveAttribute(template, label);
        }
      } else {
//      domSetAttribute(template, label, STRING_empty + value);
jQuery(template).attr(label, STRING_empty + value);
      }
    }
  }
};

/**
 * Implements the jscontent attribute. Evalutes the expression in
 * jscontent in the current context and with the current variables,
 * and assigns its string value to the content of the current template
 * node.
 *
 * @param {JsEvalContext} context Current evaluation context.
 *
 * @param {Element} template Currently processed template node.
 *
 * @param {Function} content Processed value of the jscontent
 * attribute.
 */
JstProcessor.prototype.jstContent_ = function(context, template, content) {
  // NOTE: Profiling shows that this method costs significant
  // time. In jstemplate_perf.html, it's about 50%. I tried to replace
  // by HTML escaping and assignment to innerHTML, but that was even
  // slower.
  var value = STRING_empty + context.jsexec(content, template);
  // Prevent flicker when refreshing a template and the value doesn't
  // change.
  if (template.innerHTML == value) {
    return;
  }
  while (template.firstChild) {
    domRemoveNode(template.firstChild);
  }
  var t = domCreateTextNode(this.document_, value);
  domAppendChild(template, t);
};

/**
 * Caches access to and parsing of template processing attributes. If
 * domGetAttribute() is called every time a template attribute value
 * is used, it takes more than 10% of the time.
 *
 * @param {Element} template A DOM element node of the template.
 *
 * @return {Object} A javascript object that has all js template
 * processing attribute values of the node as properties.
 */
JstProcessor.prototype.jstAttributes_ = function(template) {
  if (template[PROP_jstcache]) {
    return template[PROP_jstcache];
  }

  var jstid = domGetAttribute(template, ATT_jstcache);
  if (jstid) {
    return template[PROP_jstcache] = JstProcessor.jstcache_[jstid];
  }

  return JstProcessor.prepareNode_(template);
};

/**
 * Helps to implement the transclude attribute, and is the initial
 * call to get hold of a template from its ID.
 *
 * If the ID is not present in the DOM, and opt_loadHtmlFn is specified, this
 * function will call that function and add the result to the DOM, before
 * returning the template.
 *
 * @param {string} name The ID of the HTML element used as template.
 * @param {Function} opt_loadHtmlFn A function which, when called, will return
 *   HTML that contains an element whose ID is 'name'.
 *
 * @return {Element|null} The DOM node of the template. (Only element nodes
 * can be found by ID, hence it's a Element.)
 */
function jstGetTemplate(name, opt_loadHtmlFn) {
  var doc = document;
  var section;
  if (opt_loadHtmlFn) {
    section = jstLoadTemplateIfNotPresent(doc, name, opt_loadHtmlFn);
  } else {
    section = domGetElementById(doc, name);
  }
  if (section) {
    JstProcessor.prepareTemplate_(section);
    var ret = domCloneElement(section);
    domRemoveAttribute(ret, STRING_id);
    return ret;
  } else {
    return null;
  }
}

/**
 * This function is the same as 'jstGetTemplate' but, if the template
 * does not exist, throw an exception.
 *
 * @param {string} name The ID of the HTML element used as template.
 * @param {Function} opt_loadHtmlFn A function which, when called, will return
 *   HTML that contains an element whose ID is 'name'.
 *
 * @return {Element} The DOM node of the template. (Only element nodes
 * can be found by ID, hence it's a Element.)
 */
function jstGetTemplateOrDie(name, opt_loadHtmlFn) {
  var x = jstGetTemplate(name, opt_loadHtmlFn);
  //check(x !== null);
  return /** @type Element */(x);
}

/**
 * If an element with id 'name' is not present in the document, call loadHtmlFn
 * and insert the result into the DOM.
 *
 * @param {Document} doc
 * @param {string} name
 * @param {Function} loadHtmlFn A function that returns HTML to be inserted
 * into the DOM.
 * @param {string} opt_target The id of a DOM object under which to attach the
 *   HTML once it's inserted.  An object with this id is created if it does not
 *   exist.
 * @return {Element} The node whose id is 'name'
 */
function jstLoadTemplateIfNotPresent(doc, name, loadHtmlFn, opt_target) {
  var section = domGetElementById(doc, name);
  if (section) {
    return section;
  }
  // Load any necessary HTML and try again.
  jstLoadTemplate_(doc, loadHtmlFn(), opt_target || STRING_jsts);
  var section = domGetElementById(doc, name);
  if (!section) {
    log("Error: jstGetTemplate was provided with opt_loadHtmlFn, " +
	"but that function did not provide the id '" + name + "'.");
  }
  return /** @type Element */(section);
}

/**
 * Loads the given HTML text into the given document, so that
 * jstGetTemplate can find it.
 *
 * We append it to the element identified by targetId, which is hidden.
 * If it doesn't exist, it is created.
 *
 * @param {Document} doc The document to create the template in.
 *
 * @param {string} html HTML text to be inserted into the document.
 *
 * @param {string} targetId The id of a DOM object under which to attach the
 *   HTML once it's inserted.  An object with this id is created if it does not
 *   exist.
 */
function jstLoadTemplate_(doc, html, targetId) {
  var existing_target = domGetElementById(doc, targetId);
  var target;
  if (!existing_target) {
    target = domCreateElement(doc, STRING_div);
    target.id = targetId;
    displayNone(target);
    positionAbsolute(target);
    domAppendChild(doc.body, target);
  } else {
    target = existing_target;
  }
  var div = domCreateElement(doc, STRING_div);
  target.appendChild(div);
  div.innerHTML = html;
}

/**
 * Sets the jsinstance attribute on a node according to its context.
 *
 * @param {Element} template The template DOM node to set the instance
 * attribute on.
 *
 * @param {Array} values The current input context, the array of
 * values of which the template node will render one instance.
 *
 * @param {number} index The index of this template node in values.
 */
function jstSetInstance(template, values, index) {
  if (index == jsLength(values) - 1) {
    domSetAttribute(template, ATT_instance, CHAR_asterisk + index);
  } else {
    domSetAttribute(template, ATT_instance, STRING_empty + index);
  }
}

/**
 * Log the current state.
 * @param {string} caller An identifier for the caller of .log_.
 * @param {Element} template The template node being processed.
 * @param {Object} jstAttributeValues The jst attributes of the template node.
 */
//JstProcessor.prototype.logState_ = function(
//    caller, template, jstAttributeValues) {
//  if (MAPS_DEBUG) {
//    var msg = '<table>';
//    msg += '<caption>' + caller + '</caption>';
//    msg += '<tbody>';
//    if (template.id) {
//      msg += '<tr><td>' + 'id:' + '</td><td>' + template.id + '</td></tr>';
//    }
//    if (template.name) {
//      msg += '<tr><td>' + 'name:' + '</td><td>' + template.name + '</td></tr>';
//    }
//    if (jstAttributeValues) {
//      msg += '<tr><td>' + 'attr:' +
//      '</td><td>' + /*jsToSource*/(jstAttributeValues) + '</td></tr>';
//    }
//    msg += '</tbody></table><br/>';
//    this.logs_.push(msg);
//  }
//};

/**
 * Retrieve the processing logs.
 * @return {Array.<string>} The processing logs.
 */
//JstProcessor.prototype.getLogs = function() {
//  return this.logs_;
//};

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
/**
 * @fileoverview Prototype for OpenSocial Templates implementation.
 *
 * Simple usage of templates:
 *   var template = os.compileTemplate("<span>Hello, ${name}</span>");
 *   template.renderInto(document.getElementById("output"), { name: "Bob" });
 *
 * More complex usecase:
 *   var data = { ... };
 *   var template = os.compileTemplate(document.getElementById("template"));
 *   var context = os.createContext(data);
 *   var output = template.render(data, context);
 *   // ... attach the output node ...
 *   os.fireCallbacks(context);
 *
 * TODO(levik): Optimization:
 *   - Define all regexps as globals once, not once per function call.
 *   - Use queue-based DOM walker instead of recursion.
 *   - doTag() safeguards node from abuse (no parent access, etc).
 */

//opensocial = opensocial || {};
//opensocial.template = opensocial.template || {};
//var os = opensocial.template;
var os = {};

/**
 * Sends a log to the console. Currently uses Firebug console if available,
 * otherwise supresses the message.
 * TODO: What other logging APIs can we use? Does gadgets provide one?
 * @param {string} msg The message to send.
 */
//os.log = function(msg) {
//  var console = window['console'];
//  if (console && console.log) {
//    console.log(msg);
//  }
//};

// Register our logging function as the global logger function.
// TODO: Remove global variables once JsTemplates supports setting logger
//window['log'] = os.log;

/**
 * Logs a warning to the console.
 */
//os.warn = function(msg) {
//  os.log("WARNING: " + msg);
//};

/**
 * Is the object an array? 
 */
os.isArray = function(obj) {
  return typeof(obj) == "object" && 
      typeof(obj.length) == "number" && 
      typeof(obj.push) == "function";
};

/**
 * Constants
 * TODO(davidbyttow): Pull these out of os and make them global (optimization)
 */
//os.ATT_customtag = "customtag";

os.VAR_my = "$my";
//os.VAR_cur = "$cur";
os.VAR_node = "$node";
os.VAR_msg = "Msg";
//os.VAR_parentnode = "$parentnode";
os.VAR_uniqueId = "$uniqueId";
os.VAR_identifierresolver = "$_ir";
os.VAR_emptyArray = "$_ea";
//os.VAR_callbacks = "$callbacks_";

/**
 * Reusable empty array instance
 * IE6 PERF: To avoid creating empty arrays when they are needed. 
 */
os.EMPTY_ARRAY = [];

/**
 * Regular expressions
 * TODO(levik): Move all regular expressions here.
 */
os.regExps_ = {
  ONLY_WHITESPACE: /^[ \t\n]*$/,
  VARIABLE_SUBSTITUTION: /^([\w\W]*?)(\$\{[^\}]*\})([\w\W]*)$/
};

/**
 * Preprocess the template.
 * @param {Element|TextNode|string} node DOM node containing the template data, or the
 * string source.
 * @param {string} opt_id An optional ID for the new template.
 * @return {os.Template} A compiled Template object
 */
//os.compileTemplate = function(node, opt_id) {
//  // Allow polymorphic behavior.
//  if (typeof(node) == "string") {
//    return os.compileTemplateString(node, opt_id);
//  }
//
//  opt_id = opt_id || node.name;
//  var src = node.value || node.innerHTML;
//  src = os.trim(src);
//  var template = os.compileTemplateString(src, opt_id, node);
//  // Decorate the node with the template's ID, so we consistently render it
//  // into the same DIV, and so that it doesn't get treated as anonymous anymore.
//  if (! node.name) {
//    node.name = template.id;
//  }
//  return template;
//};

/**
 * Compile a template without requiring a DOM node.
 * @param {string} src XML data to be compiled.
 * @param {string} opt_id An optional ID for the new template.
 * @param {Element} opt_container An optional container DOM Element 
 * to look for namespaces
 * @return {opensocial.template.Template} A compiled Template object.
 */
//os.compileTemplateString = function(src, opt_id, opt_container) {
//  src = opensocial.xmlutil.prepareXML(src, opt_container);
//  var doc = opensocial.xmlutil.parseXML(src);
//  return os.compileXMLDoc(doc, opt_id);
//};

/**
 * Render one compiled node with a context.
 * @return {Element} a DOM element containing the result of template processing
 */
//os.renderTemplateNode_ = function(compiledNode, context) {
//  var template = domCloneElement(compiledNode);
//  if (template.removeAttribute) {
//    template.removeAttribute(STRING_id);
//  }
//  jstProcess(context, template);
//  return template;
//};

/**
 * @type {number} A global counter for rendered elements.
 * @private
 */
//os.elementIdCounter_ = 0;

/**
 * Creates a custom tag function for rendering a compiled template.
 */
//os.createTemplateCustomTag = function(template) {
//  return function(node, data, context) {
//    context.setVariable(os.VAR_my, node);
//    context.setVariable(os.VAR_node, node);
//    context.setVariable(os.VAR_uniqueId, os.elementIdCounter_++);
//    var ret = template.render(data, context);
//
//    // Prevent reprocessing after attachment.
//    os.markNodeToSkip(ret);
//
//    return ret;
//  };
//};

/**
 * Creates a map of the named children of a node. Lower-cased element names 
 * (including transformed custom tags) are used as keys. 
 * Where multiple elements share a name, the map value will be an array.
 * @param {Element} node The node whose children are to be mapped
 * @return {object} A Map of Element names to Elements.
 */
//os.computeChildMap_ = function(node) {
//  var map = {};
//  for (var i = 0; i < node.childNodes.length; i++) {
//    var child = node.childNodes[i];
//    if (!child.tagName) {
//      continue;
//    }
//    var name = child.getAttribute(os.ATT_customtag);    
//    if (name) {
//      var parts = name.split(":");
//      parts.length == 2 ? name = parts[1] : name = parts[0];
//    } else {
//      name = child.tagName;
//    }
//    name = name.toLowerCase();
//    var prev = map[name];
//    if (!prev) {
//      map[name] = child;
//    } else if (os.isArray(prev)) {
//      prev.push(child);
//    } else {
//      map[name] = [];
//      map[name].push(prev);
//      map[name].push(child);
//    }
//  }
//  return map;
//};

/**
 * Creates a functor which returns a value from the specified node given a
 * name.
 * @param {Node} node Node to get the value from.
 * @return {Function} The functor which takes a type {string}.
 * @private
 */
//os.createNodeAccessor_ = function(node) {
//  return function(name) {
//    return os.getValueFromNode_(node, name);
//  };
//};

/**
 * A singleton instance of the current gadget Prefs - only instantiated if
 * we are in a gadget container.
 * @type gadgets.Prefs
 */
//os.gadgetPrefs_ = null;
//if (window['gadgets'] && window['gadgets']['Prefs']) {
//  os.gadgetPrefs_ = new window['gadgets']['Prefs']();
//};

/**
 * A convenience function to get a localized message by key from the shared
 * gadgets.Prefs object.
 * @param {string} key The message key to get
 * @return {string|null} The localized message for a given key, or null if not
 * found, or not in the gadgets environment.
 */
//os.getPrefMessage = function(key) {
//  if (!os.gadgetPrefs_) {
//    return null;
//  }
//  return os.gadgetPrefs_.getMsg(key);
//};

/**
 * A map of custom attributes keyed by attribute name.
 * Maps {string} types onto Function({Element|string|Object|JSEvalContext}).
 * @type {Object}
 * @private
 */
//os.customAttributes_ = {};

/**
 * Registers a custom attribute functor. When this attribute is encountered in
 * a DOM node, the specified functor will be called.
 * @param {string} attrName The name of the custom attribute.
 * @param {Function} functor A function with signature
 *     function({Element}, {string}, {Object}, {JSEvalContext})
 */
//os.registerAttribute_ = function(attrName, functor) {
//  os.customAttributes_[attrName] = functor;
//};

/**
 * Calls a pre-registered custom attribute handler.
 */
//os.doAttribute = function(node, attrName, data, context) {
//  if (!os.customAttributes_.hasOwnProperty(attrName)) {
//    return;
//  }
//  var attrFunctor = os.customAttributes_[attrName];
//  attrFunctor(node, node.getAttribute(attrName), data, context);
//};

/**
 * Processes a custom tag by invoking the appropriate custom tag function.
 * @param {Element} node Parent DOM node.
 * @param {string} ns Namespace.
 * @param {string} tag Tag name.
 * @param {Object} data Current evaluation data.
 * @param {Object} context JSEvalContext object encapsulating data.
 */
//os.doTag = function(node, ns, tag, data, context) {
//  var tagFunction = os.getCustomTag(ns, tag);
//  if (!tagFunction) {
//    os.warn("Custom tag <" + ns + ":" + tag + "> not defined.");
//    return;
//  }
//
//  var ctx = null;
//  // Process tag's inner content before processing the tag.
//  for (var child = node.firstChild; child; child = child.nextSibling) {    
//    if (child.nodeType == DOM_ELEMENT_NODE) {
//      if (ctx == null) {        
//        var selectInner = node[PROP_jstcache] ? node[PROP_jstcache][ATT_innerselect] : null;
//        if (selectInner) {
//          var data = context.jsexec(selectInner, node);
//          ctx = context.clone(data, 0, 0);
//        } else {
//          ctx = context;          
//        }
//      }
//      jstProcess(ctx, child);
//      os.markNodeToSkip(child);
//    }
//  }  
//  
//  ctx = context.clone({}, 0, 0);
//  var result = tagFunction.call(null, node, data, ctx);
//
//  if (!result && typeof(result) != "string") {
//    throw Error("Custom tag <" + ns + ":" + tag + "> failed to return anything.");
//  }
//
//  if (typeof(result) == "string") {
//    node.innerHTML = result ? result : "";
//  } else if (os.isArray(result)) {
//    os.removeChildren(node);
//    for (var i = 0; i < result.length; i++) {
//      if (result[i].nodeType == DOM_ELEMENT_NODE ||
//          result[i].nodeType == DOM_TEXT_NODE) {
//        node.appendChild(result[i]);
//        if (result[i].nodeType == DOM_ELEMENT_NODE) {
//          os.markNodeToSkip(result[i]);
//        }
//      }
//    }
//  } else {
//    var callbacks = context.getVariable(os.VAR_callbacks);
//    var resultNode = null;
//    if (result.nodeType == DOM_ELEMENT_NODE) {
//      resultNode = result;
//    } else if (result.root && result.root.nodeType == DOM_ELEMENT_NODE) {
//      resultNode = result.root;
//    }
//
//    // Only attach the result DOM if it's not the same as the container node,
//    // or not already attached. In IE, detached nodes can be parented in
//    // DocumentFragments, so we check for that as well.
//    if (resultNode && resultNode != node && (
//        !resultNode.parentNode ||
//        resultNode.parentNode.nodeType == DOM_DOCUMENT_FRAGMENT_NODE)) {
//      os.removeChildren(node);
//      node.appendChild(resultNode);
//      os.markNodeToSkip(resultNode);
//    }
//    if (result.onAttach) {
//      callbacks.push(result);
//    }
//  }
//};


/**
 * Checks the current context, and if it's an element node, sets it to be used
 * for future <os:renderAll/> operations.
 */
os.setContextNode_ = function(data, context) {
//  if (data.nodeType == DOM_ELEMENT_NODE) {
    context.setVariable(os.VAR_node, data);
//  }
};

/**
 * Mark the node to not be re-processed by continued template processing.
 * Useful if the node contains a template that needs to be processed with a
 * different context.
 */
//os.markNodeToSkip = function(node) {
//  node.setAttribute(ATT_skip, "true");
//
//  // Remove the attributes processed when jsskip is true
//  node.removeAttribute(ATT_select);
//  node.removeAttribute(ATT_eval);
//  node.removeAttribute(ATT_values);
//  node.removeAttribute(ATT_display);
//
//  // Cause the cache to be re-calculated
//  node[PROP_jstcache] = null;
//  node.removeAttribute(ATT_jstcache);
//};

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
/**
 * @fileoverview Implements compiler functionality for OpenSocial Templates.
 *
 * TODO(davidbyttow): Move into os.Compiler.
 */

/**
 * Literal semcolons have special meaning in JST, so we need to change them to
 * variable references.
 */
os.SEMICOLON = ';';

/**
 * Check if the browser is Internet Explorer.
 *
 * TODO(levik): Find a better, more general way to do this, esp. if we need
 * to do other browser checks elswhere.
 */
os.isIe = navigator.userAgent.indexOf('Opera') != 0 &&
    navigator.userAgent.indexOf('MSIE') != -1;

/**
 * Takes an XML node containing Template markup and compiles it into a Template.
 * The node itself is not considered part of the markup.
 * @param {Node} node XML node to be compiled.
 * @param {string} opt_id An optional ID for the new template.
 * @return {os.Template} A compiled Template object.
 */
//os.compileXMLNode = function(node, opt_id) {
//  var nodes = [];
//  for (var child = node.firstChild; child; child = child.nextSibling) {
//    if (child.nodeType == DOM_ELEMENT_NODE) {
//      nodes.push(os.compileNode_(child));
//    } else if (child.nodeType == DOM_TEXT_NODE) {
//      if (child != node.firstChild ||
//          !child.nodeValue.match(os.regExps_.ONLY_WHITESPACE)) {
//        var compiled = os.breakTextNode_(child);
//        for (var i = 0; i < compiled.length; i++) {
//          nodes.push(compiled[i]);
//        }
//      }
//    }
//  }
//  var template = new os.Template(opt_id);
//  template.setCompiledNodes_(nodes);
//  return template;
//};

/**
 * Takes an XML Document and compiles it into a Template object.
 * @param {Document} doc XML document to be compiled.
 * @param {string} opt_id An optional ID for the new template.
 * @return {os.Template} A compiled Template object.
 */
//os.compileXMLDoc = function(doc, opt_id) {
//  var node = doc.firstChild;
//  // Find the <root> node (skip DOCTYPE).
//  while (node.nodeType != DOM_ELEMENT_NODE) {
//    node = node.nextSibling;
//  }
//
//  return os.compileXMLNode(node, opt_id);
//};

/**
 * Map of special operators to be transformed.
 */
os.operatorMap = {
  'and': '&&',
  'eq': '==',
  'lte': '<=',
  'lt': '<',
  'gte': '>=',
  'gt': '>',
  'neq': '!=',
  'or': '||',
  'not': '!'
};

/**
 * Shared regular expression to split a string into lexical parts. Quoted 
 * strings are treated as tokens, so are identifiers and any characters between 
 * them.
 * In "foo + bar = 'baz - bing'", the tokens are
 *   ["foo", " + ", "bar", " = ", "'baz - bing'"]
 */
os.regExps_.SPLIT_INTO_TOKENS = 
  /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\w+|[^"'\w]+/g;
  
/**
 * Parses operator markup into JS code. See operator map above.
 *
 * TODO: Simplify this to only work on neccessary operators - binary ones that
 * use "<" or ">".
 *
 * @param {string} src The string snippet to parse.
 */
os.remapOperators_ = function(src) {
  return src.replace(os.regExps_.SPLIT_INTO_TOKENS, 
      function (token) { 
        return os.operatorMap.hasOwnProperty(token) ? 
            os.operatorMap[token] : token;
      });
};

/**
 * Remap variable references in the expression.
 * @param {string} expr The expression to transform.
 * @return {string} Transformed exression.
 */
os.transformVariables_ = function(expr) {
  expr = os.replaceTopLevelVars_(expr);

  return expr;
};

/**
 * Map of variables to transform
 */
os.variableMap_ = {
  'my': os.VAR_my,
  'My': os.VAR_my,
  'cur': VAR_this,
  'Cur': VAR_this,
  '$cur': VAR_this,
  'Top': VAR_top,
  'Context': VAR_loop  
};

/**
 * Replace the top level variables
 * @param {string} expr The expression
 * @return {string} Expression with replacements
 */
os.replaceTopLevelVars_ = function(text) {

  var regex;

  regex = os.regExps_.TOP_LEVEL_VAR_REPLACEMENT;
  if (!regex) {
    regex = /(^|[^.$a-zA-Z0-9])([$a-zA-Z0-9]+)/g;
    os.regExps_.TOP_LEVEL_VAR_REPLACEMENT = regex;
  }

  return text.replace(regex,
      function (whole, left, right) { 
        if (os.variableMap_.hasOwnProperty(right)) { 
          return left + os.variableMap_[right]; 
        } else { 
          return whole; 
        } 
      });
};

/**
 * This function is used to lookup named properties of objects.
 * By default only a simple lookup is performed, but using
 * os.setIdentifierResolver() it's possible to plug in a more complex function,
 * for example one that looks up foo -> getFoo() -> get("foo").
 *
 * TODO: This should not be in compiler.
 */
os.identifierResolver_ = function(data, name) {
//  return data.hasOwnProperty(name) ? data[name] : ('get' in data ? data.get(name) : null);
return data.hasOwnProperty(name) ? data[name] : undefined;
};

/**
 * Sets the Identifier resolver function. This is global, and must be done
 * before any compilation of templates takes place.
 *
 * TODO: This should possibly not be in compiler?
 */
//os.setIdentifierResolver = function(resolver) {
//  os.identifierResolver_ = resolver;
//};

/**
 * Gets a named property from a JsEvalContext (by checking data_ and vars_) or
 * from a simple JSON object by looking at properties. The IdentifierResolver
 * function is used in either case.
 *
 * TODO: This should not be in compiler.
 *
 * @param {JsEvalContext|Object} context Context to get property from
 * @param {String} name Name of the property
 * @return {Object|String}
 */
os.getFromContext = function(context, name, opt_default) {
  if (!context) {
    return opt_default;
  }
  var ret;
  // Check if this is a context object.
  if (context.vars_ && context.data_) {
    // Is the context payload a DOM node?
    if (context.data_.nodeType == DOM_ELEMENT_NODE) {
      ret = os.getValueFromNode_(context.data_, name);
      if (ret == null) {        
        // Set to undefined
        ret = void(0);
      }
    } else {
      ret = os.identifierResolver_(context.data_, name);
    }
    if (typeof(ret) == "undefined") {
      ret = os.identifierResolver_(context.vars_, name);
    }
    if (typeof(ret) == "undefined" && context.vars_[os.VAR_my]) {
      ret = os.getValueFromNode_(context.vars_[os.VAR_my], name);
    }
    if (typeof(ret) == "undefined" && context.vars_[VAR_top]) {
      ret = context.vars_[VAR_top][name];
    }
  } else if (context.nodeType == DOM_ELEMENT_NODE) {
    // Is the context a DOM node?
    ret = os.getValueFromNode_(context, name);
  } else {
    ret = os.identifierResolver_(context, name);
  }
  if (typeof(ret) == "undefined" || ret == null) {
    if (typeof(opt_default) != "undefined") {
      ret = opt_default;
    } else {
      ret = "";
    }
  } else if (opt_default && os.isArray(opt_default) && !os.isArray(ret) && 
      ret.list && os.isArray(ret.list)) {
    // If we were trying to get an array, but got a JSON object with an
    // array property "list", return that instead.
    ret = ret.list;    
  }
  return ret;
};

/**
 * Prepares an expression for JS evaluation.
 * @param {string} expr The expression snippet to parse.
 * @param {string} opt_default An optional default value reference (such as the
 * literal string 'null').
 */
os.transformExpression_ = function(expr, opt_default) {
  expr = os.remapOperators_(expr);
  expr = os.transformVariables_(expr);
//  if (os.identifierResolver_) {
    expr = os.wrapIdentifiersInExpression(expr, opt_default);
//  }
  return expr;
};

/**
 * A Map of special attribute names to change while copying attributes during
 * compilation. The key is OST-spec attribute, while the value is JST attribute
 * used to implement that feature.
 */
//os.attributeMap_ = {
//  'if': ATT_display,
//  'repeat': ATT_select,
//  'cur': ATT_innerselect
//};

/**
 * Appends a JSTemplate attribute value while maintaining previous values.
 */
os.appendJSTAttribute_ = function(node, attrName, value) {
  var previousValue = node.getAttribute(attrName);
  if (previousValue) {
    value = previousValue + ";" + value;
  }
  node.setAttribute(attrName, value);
};

/**
 * Copies attributes from one node (xml or html) to another (html),.
 * Special OpenSocial attributes are substituted for their JStemplate
 * counterparts.
 * @param {Element} from An XML or HTML node to copy attributes from.
 * @param {Element} to An HTML node to copy attributes to.
 * @param {String} opt_customTag The name of the custom tag, being processed if
 * any.
 *
 * TODO(levik): On IE, some properties/attributes might be case sensitive when
 * set through script (such as "colSpan") - since they're not case sensitive
 * when defined in HTML, we need to support this type of use.
 */
os.copyAttributes_ = function(from, to, opt_customTag) {

// expr
var expr = function(value) {
  if (value.length > 3 && value.substring(0, 2) == '${' && value.charAt(value.length - 1) == '}')
    value = value.substring(2, value.length - 1);
  return value;
};

var node = $(from);

// repeat
var value = node.attr('repeat');
if (value) {
  os.appendJSTAttribute_(node[0], ATT_eval, "os.setContextNode_($this,$context)");
  node.attr(ATT_select, os.transformExpression_(expr(value), os.VAR_emptyArray));
}

// if
value = node.attr('if');
if (value)
  node.attr(ATT_display, os.transformExpression_(expr(value), 'null'));

// var
var value = node.attr('var');
if (value)
  os.appendJSTAttribute_(node[0], ATT_vars, value + ':$this');

// index

// context

// HTML
// checked,selected
jQuery.each('alt,class,href,id,src,style,target,title,value'.split(','), function(i, name) {
  var value = node.attr(name);
  if (value) {
    var substitution = os.parseAttribute_(value);
    if (substitution)
      os.appendJSTAttribute_(node[0], ATT_values, name + ':' + substitution);
  }
});

//  var dynamicAttributes = null;
//  for (var i = 0; i < from.attributes.length; i++) {
//    var name = from.attributes[i].nodeName;
//    var value = from.getAttribute(name);
//    if (name && value) {
//      if (name == 'var') {
//        os.appendJSTAttribute_(to, ATT_vars, from.getAttribute(name) +
//            ': $this');
//      } else if (name == 'context') {
//        os.appendJSTAttribute_(to, ATT_vars, from.getAttribute(name) +
//            ': ' + VAR_loop);
//      } else if (name.length < 7 || name.substring(0, 6) != 'xmlns:') {
//        if (os.customAttributes_[name]) {
//          os.appendJSTAttribute_(to, ATT_eval, "os.doAttribute(this, '" + name +
//              "', $this, $context)");
//        } else if (name == 'repeat') {
//          os.appendJSTAttribute_(to, ATT_eval,
//              "os.setContextNode_($this, $context)");
//        }
//        var outName = os.attributeMap_.hasOwnProperty(name) ? 
//            os.attributeMap_[name] : name;
//        var substitution =
//            (os.attributeMap_[name]) ?
//            null : os.parseAttribute_(value);
//
//        if (substitution) {
//          if (outName == 'class') {
//            // Dynamically setting the @class attribute gets ignored by the
//            // browser. We need to set the .className property instead.
//            outName = '.className';
//          } else if (outName == 'style') {
//            // Similarly, on IE, setting the @style attribute has no effect.
//            // The cssText property of the style object must be set instead.
//            outName = '.style.cssText';
//          } else if (to.getAttribute(os.ATT_customtag)) {
//            // For custom tags, it is more useful to put values into properties
//            // where they can be accessed as objects, rather than placing them
//            // into attributes where they need to be serialized.
//            outName = '.' + outName;
//          } else if (os.isIe && !os.customAttributes_[outName] &&
//            outName.substring(0, 2).toLowerCase() == 'on') {
//            // For event handlers on IE, setAttribute doesn't work, so we need
//            // to create a function to set as a property.
//            outName = '.' + outName;
//            substitution = 'new Function(' + substitution + ')';
//          } else if (outName == 'selected' && to.tagName == 'OPTION') {
//            // For the @selected attribute of an option, set the property 
//            // instead to allow false values to not mark the option selected.
//            outName = '.selected'
//          }
//
//          // TODO: reuse static array (IE6 perf).
//          if (!dynamicAttributes) {
//            dynamicAttributes = [];
//          }
//          dynamicAttributes.push(outName + ':' + substitution);
//        } else {
//          // For special attributes, do variable transformation.
//          if (os.attributeMap_.hasOwnProperty(name)) {
//            // If the attribute value looks like "${expr}", just use the "expr".
//            if (value.length > 3 &&
//              value.substring(0, 2) == '${' &&
//              value.charAt(value.length - 1) == '}') {
//              value = value.substring(2, value.length - 1);
//            }
//            // In special attributes, default value is empty array for repeats,
//            // null for others
//            value = os.transformExpression_(value, 
//                name == 'repeat' ? os.VAR_emptyArray : 'null');
//          } else if (outName == 'class') {
//            // In IE, we must set className instead of class.
//            to.setAttribute('className', value);
//          } else if (outName == 'style') {
//            // Similarly, on IE, setting the @style attribute has no effect.
//            // The cssText property of the style object must be set instead.
//            to.style.cssText = value;
//          }
//          if (os.isIe && !os.customAttributes_.hasOwnProperty(outName) &&
//              outName.substring(0, 2).toLowerCase() == 'on') {
//            // In IE, setAttribute doesn't create event handlers, so we must
//            // use attachEvent in order to create handlers that are preserved
//            // by calls to cloneNode().
//            to.attachEvent(outName, new Function(value));
//          } else {
//          to.setAttribute(outName, value);
//          }
//        }
//      }
//    }
//  }
//
//  if (dynamicAttributes) {
//    os.appendJSTAttribute_(to, ATT_values, dynamicAttributes.join(';'));
//  }
};

/**
 * Recursively compiles an individual node from XML to DOM (for JSTemplate)
 * Special os.* tags and tags for which custom functions are defined
 * are converted into markup recognizable by JSTemplate.
 *
 * TODO: process text nodes and attributes  with ${} notation here
 */
os.compileNode_ = function(node) {
  if (node.nodeType == DOM_TEXT_NODE) {
//    var textNode = node.cloneNode(false);
//    return os.breakTextNode_(textNode);
jQuery(node).replaceWith(os.breakTextNode_(node));
  } else if (node.nodeType == DOM_ELEMENT_NODE) {
os.copyAttributes_(node, node);
if (!os.processTextContent_(node, node))
  jQuery(node.childNodes).each(function(i, child) {
    os.compileNode_(child);
  });
//    var output;
//    if (node.tagName.indexOf(":") > 0) {
//      if (node.tagName == "os:Repeat") {
//        output = document.createElement(os.computeContainerTag_(node));
//        output.setAttribute(ATT_select, os.parseAttribute_(node.getAttribute("expression")));
//        var varAttr = node.getAttribute("var");
//        if (varAttr) {
//          os.appendJSTAttribute_(output, ATT_vars, varAttr + ': $this');
//        }
//        var contextAttr = node.getAttribute("context");
//        if (contextAttr) {
//          os.appendJSTAttribute_(output, ATT_vars, contextAttr + ': ' + VAR_loop);
//        }
//        os.appendJSTAttribute_(output, ATT_eval, "os.setContextNode_($this, $context)");
//      } else if (node.tagName == "os:If") {
//        output = document.createElement(os.computeContainerTag_(node));
//        output.setAttribute(ATT_display, os.parseAttribute_(node.getAttribute("condition")));
//      } else {
//        output = document.createElement("span");
//        output.setAttribute(os.ATT_customtag, node.tagName);
//
//        var custom = node.tagName.split(":");
//        os.appendJSTAttribute_(output, ATT_eval, "os.doTag(this, \""
//            + custom[0] + "\", \"" + custom[1] + "\", $this, $context)");
//        var context = node.getAttribute("cur") || "{}";
//        output.setAttribute(ATT_innerselect, context);
//
//        // For os:Render, create a parent node reference.
//        // TODO: remove legacy support
//        if (node.tagName == "os:render" || node.tagName == "os:Render" ||
//            node.tagName == "os:renderAll" || node.tagName == "os:RenderAll") {
//          os.appendJSTAttribute_(output, ATT_values, os.VAR_parentnode + ":" +
//              os.VAR_node);
//        }
//
//        os.copyAttributes_(node, output, node.tagName);
//      }
//    } else {
//      output = os.xmlToHtml_(node);
//    }
//    if (output && !os.processTextContent_(node, output)) {
//      for (var child = node.firstChild; child; child = child.nextSibling) {
//        var compiledChild = os.compileNode_(child);
//        if (compiledChild) {
//          if (os.isArray(compiledChild)) {
//            for (var i = 0; i < compiledChild.length; i++) {
//              output.appendChild(compiledChild[i]);
//            }
//          } else {
//            // If inserting a TR into a TABLE, inject a TBODY element.
//            if (compiledChild.tagName == 'TR' && output.tagName == 'TABLE') {
//              var lastEl = output.lastChild;
//              while (lastEl && lastEl.nodeType != DOM_ELEMENT_NODE &&
//                  lastEl.previousSibling) {
//                lastEl = lastEl.previousSibling;
//              }
//              if (!lastEl || lastEl.tagName != 'TBODY') {
//                lastEl = document.createElement('tbody');
//                output.appendChild(lastEl);
//              }
//              lastEl.appendChild(compiledChild);
//            } else {
//              output.appendChild(compiledChild);
//            }
//          }
//        }
//      }
//    }
//    return output;
  }
//  return null;
};

/**
 * Calculates the type of element best suited to encapsulating contents of a 
 * <os:Repeat> or <os:If> tags. Inspects the element's children to see if one 
 * of the special cases should be used.
 * "optgroup" for <option>s
 * "tbody" for <tr>s
 * "span" otherwise
 * @param {Element} element The repeater/conditional element
 * @return {stirng} Name of the node ot represent this repeater.
 */
//os.computeContainerTag_ = function(element) {
//  var child = element.firstChild;
//  if (child) {
//    while (child && !child.tagName) {
//      child = child.nextSibling;
//    }
//    if (child) {
//      var tag = child.tagName.toLowerCase();
//      if (tag == "option") {
//        return "optgroup";
//      }
//      if (tag == "tr") {
//        return "tbody";
//      }
//    }
//  }
//  return "span";
//};

/**
 * XHTML Entities we need to support in XML, defined in DOCTYPE format.
 *
 * TODO(levik): A better way to do this.
 */
//os.ENTITIES = "<!ENTITY nbsp \"&#160;\">";

/**
 * Creates an HTML node that's a shallow copy of an XML node
 * (includes attributes).
 */
//os.xmlToHtml_ = function(xmlNode) {
//  var htmlNode = document.createElement(xmlNode.tagName);
//  os.copyAttributes_(xmlNode, htmlNode);
//  return htmlNode;
//};

/**
 * Fires callbacks on a context object
 */
//os.fireCallbacks = function(context) {
//  var callbacks = context.getVariable(os.VAR_callbacks);
//  while (callbacks.length > 0) {
//    var callback = callbacks.pop();
//    if (callback.onAttach) {
//      callback.onAttach();
//    // TODO(levik): Remove no-context handlers?
//    } else if (typeof(callback) == "function") {
//      callback.apply({});
//    }
//  }
//};

/**
 * Checks for and processes an optimized case where a node only has text content
 * In this instance, any variable substitutions happen without creating
 * intermediary spans.
 *
 * This will work when node content looks like:
 *   - "Plain text"
 *   - "${var}"
 *   - "Plain text with ${var} inside"
 * But not when it is
 *   - "Text <b>With HTML content</b> (with or without a ${var})
 *   - Custom tags are also exempt from this optimization.
 *
 * @return {boolean} true if node only had text data and needs no further
 * processing, false otherwise.
 */
os.processTextContent_ = function(fromNode, toNode) {
  if (fromNode.childNodes.length == 1 &&
//      !toNode.getAttribute(os.ATT_customtag) &&
      fromNode.firstChild.nodeType == DOM_TEXT_NODE) {
    var substitution = os.parseAttribute_(fromNode.firstChild.data);
    if (substitution) {
      toNode.setAttribute(ATT_content, substitution);
//    } else {
//      toNode.appendChild(document.createTextNode(
//          os.trimWhitespaceForIE_(fromNode.firstChild.data, true, true)));
    }
    return true;
  }
  return false;
};

/**
 * Create a textNode out of a string, if non-empty, then puts into an array.
 * @param {string} text A string to be created as a text node.
 */
os.pushTextNode = function(array, text) {
  if (text.length > 0) {
    array.push(document.createTextNode(text));
  }
};

/**
 * Removes extra whitespace and newline characters for IE - to be used for
 * transforming strings that are destined for textNode content.
 * @param {string} string The string to trim spaces from.
 * @param {boolean} opt_trimStart Trim the start of the string.
 * @param {boolean} opt_trimEnd Trim the end of the string.
 * @return {string} The string with extra spaces removed on IE, original
 * string on other browsers.
 */
os.trimWhitespaceForIE_ = function(string, opt_trimStart, opt_trimEnd) {
  if (os.isIe) {
    // Replace newlines with spaces, then multiple spaces with single ones.
    // Then remove leading and trailing spaces.
    var ret = string.replace(/[\x09-\x0d ]+/g, ' ');
    if (opt_trimStart) {
      ret = ret.replace(/^\s/, '');
    }
    if (opt_trimEnd) {
      ret = ret.replace(/\s$/, '');
    }
    return ret;
  }
  return string;
};

/**
 * Breaks up a text node with special ${var} markup into a series of text nodes
 * and spans with appropriate jscontent attribute.
 *
 * @return {Array.<Node>} An array of textNodes and Span Elements if variable
 * substitutions were found, or an empty array if none were.
 */
os.breakTextNode_ = function(textNode) {
  var substRex = os.regExps_.VARIABLE_SUBSTITUTION;
  var text = textNode.data;
  var nodes = [];
  var match = text.match(substRex);
  while (match) {
    if (match[1].length > 0) {
      os.pushTextNode(nodes, os.trimWhitespaceForIE_(match[1]));
    }
    var token = match[2].substring(2, match[2].length - 1);
    if (!token) {
      token = VAR_this;
    }
    var tokenSpan = document.createElement("span");
    tokenSpan.setAttribute(ATT_content, os.transformExpression_(token));
    nodes.push(tokenSpan);
    match = text.match(substRex);
    text = match[3];
    match = text.match(substRex);
  }
  if (text.length > 0) {
    os.pushTextNode(nodes, os.trimWhitespaceForIE_(text));
  }
  return nodes;
};

/**
 * Transforms a literal string for inclusion into a variable evaluation 
 * (a JS string):
 *   - Escapes single quotes.
 *   - Replaces newlines with spaces.
 *   - Substitutes variable references for literal semicolons.
 *   - Addes single quotes around the string.
 */
os.transformLiteral_ = function(string) {
  return "'" + string.replace(/'/g, "\\'").
      replace(/\n/g, " ").replace(/;/g, "'+os.SEMICOLON+'") + "'";
};

/**
 * Parses an attribute value into a JS expression. "Hello, ${user}!" becomes
 * "Hello, " + user + "!".
 *
 * @param {string} value Attribute value to parse
 * TODO: Rename to parseExpression()
 */
os.parseAttribute_ = function(value) {
  if (!value.length) {
    return null;
  }
  var substRex = os.regExps_.VARIABLE_SUBSTITUTION;
  var text = value;
  var parts = [];
  var match = text.match(substRex);
  if (!match) {
    return null;
  }
  while (match) {
    if (match[1].length > 0) {
      parts.push(os.transformLiteral_(
          os.trimWhitespaceForIE_(match[1], parts.length == 0)));
    }
    var expr = match[2].substring(2, match[2].length - 1);
    if (!expr) {
      expr = VAR_this;
    }
    parts.push('(' + 
        os.transformExpression_(expr) + ')');
    text = match[3];
    match = text.match(substRex);
  }
  if (text.length > 0) {
    parts.push(os.transformLiteral_(
        os.trimWhitespaceForIE_(text, false, true)));
  }
  return parts.join('+');
};

/**
 * Returns a named value of a given node. First looks for a property, then 
 * attribute, then a child node (or nodes). If multiple child nodes are found,
 * they will be returned in an array. If we find a single Node that is an 
 * Element, it's children will be returned in an array.
 * @param {Element} node The DOM node to inspect
 * @param {string} name The name of the property/attribute/child node(s) to get.
 * The special value "*" means return all child Nodes
 * @return {string|Element|Object|Array.<Element>} The value as a String,
 * Object, Element or array of Elements.
 */
os.getValueFromNode_ = function(node, name) {

  if (name == "*") {
    var children = [];
    for (var child = node.firstChild; child; child = child.nextSibling) {
      children.push(child);
    }
    return children;
  }
  
  // Since namespaces are not supported, strip off prefix.
  if (name.indexOf(':') >= 0) {
    name = name.substring(name.indexOf(':') + 1);
  }
  
  var ret = node[name];
  if (typeof(ret) == "undefined" || ret == null) {
    ret = node.getAttribute(name);
  }
  
  if (typeof(ret) != "undefined" && ret != null) {
    // Process special cases where ret would be wrongly evaluated as "true"
    if (ret == "false") {
      ret = false;
    } else if (ret == "0") {
      ret = 0;
    }
    return ret;
  }

//  var myMap = node[os.VAR_my];
//  if (!myMap) {
//    myMap = os.computeChildMap_(node);
//    node[os.VAR_my] = myMap;
//  }
//  ret = myMap[name.toLowerCase()];
  return ret;
};

//------------------------------------------------------------------------------
// The functions below are for parsing JS expressions to wrap identifiers.
// They should be move into a separate file/js-namespace.
//------------------------------------------------------------------------------

/**
 * A map of identifiers that should not be wrapped
 * (such as JS built-ins and special method names).
 */
os.identifiersNotToWrap_ = {};
os.identifiersNotToWrap_['true'] = true;
os.identifiersNotToWrap_['false'] = true;
os.identifiersNotToWrap_['null'] = true;
os.identifiersNotToWrap_['var'] = true;
os.identifiersNotToWrap_[os.VAR_my] = true;
os.identifiersNotToWrap_[VAR_this] = true;
os.identifiersNotToWrap_[VAR_context] = true;
os.identifiersNotToWrap_[VAR_top] = true;
os.identifiersNotToWrap_[VAR_loop] = true;

/**
 * Checks if a character can begin a legal JS identifier name.
 * @param {string} ch Character to check.
 * @return {boolean} This character can start an identifier.
 */
os.canStartIdentifier= function(ch) {
  return (ch >= 'a' && ch <= 'z') ||
      (ch >= 'A' && ch <= 'Z') ||
      ch == '_' || ch == '$';
};

/**
 * Checks if a character can be contained in a legal identifier name.
 * (A legal identifier in Templates can contain any character a legal 
 * JS identifier can plus the colon - to support ${My.os:Foo})
 * @param {string} ch Character to check.
 * @return {string} This is a valid identifier character.
 */
os.canBeInIdentifier = function(ch) {
  return os.canStartIdentifier(ch) || (ch >= '0' && ch <= '9') ||
      // The colon char cannot be in a real JS identifier, but we allow it,
      // so that namespaced tag names are treated as whole identifiers.
      ch == ':';
};

/**
 * Checks if a character can be contained in a expression token.
 * @param {string} ch Character to check.
 * @return {string} This is a valid token character.
 */
os.canBeInToken = function(ch) {
  return os.canBeInIdentifier(ch) || ch == '(' || ch == ')' ||
      ch == '[' || ch == ']' || ch == '.';
};

/**
 * Wraps an identifier for Identifier Resolution with respect to the context.
 * os.VAR_idenfitierresolver ("$_ir") is used as the function name.
 * So, "foo.bar" becomes "$_ir($_ir($context, 'foo'), 'bar')"
 * @param {string} iden A string representing an identifier.
 * @param {string} opt_context A string expression to use for context.
 * @param {string} opt_default An optional default value reference (such as the
 * literal string 'null').
 */
os.wrapSingleIdentifier = function(iden, opt_context, opt_default) {
  if (os.identifiersNotToWrap_.hasOwnProperty(iden) && 
      (!opt_context || opt_context == VAR_context)) {
    return iden;
  }
  return os.VAR_identifierresolver + '(' +
      (opt_context || VAR_context) + ', \'' + iden + '\'' +
      (opt_default ? ', ' + opt_default : '') +
      ')';
};

/**
 * Wraps identifiers in a single token of JS.
 */
os.wrapIdentifiersInToken = function(token, opt_default) {
  if (!os.canStartIdentifier(token.charAt(0))) {
    return token;
  }

  // If the identifier is accessing a message
  // (and gadget messages are obtainable), inline it here.
  // TODO: This is inefficient for times when the message contains no markup -
  // such cases should be optimized.
//  if (token.substring(0, os.VAR_msg.length + 1) == (os.VAR_msg + '.') &&
//      os.gadgetPrefs_) {
if (token.substring(0, os.VAR_msg.length + 1) == (os.VAR_msg + '.')) {
    var key = token.split(".")[1];
//  var msg = os.getPrefMessage(key) || '';
var msg = jQuery.msg(key) || '';
    return os.parseAttribute_(msg) || os.transformLiteral_(msg);
  }

  var identifiers = os.tokenToIdentifiers(token);
  var parts = false;
  var buffer = [];
  var output = null;
  for (var i = 0; i < identifiers.length; i++) {
    var iden = identifiers[i];
    parts = os.breakUpParens(iden);
    if (!parts) {
      if (i == identifiers.length - 1) {
        output = os.wrapSingleIdentifier(iden, output, opt_default);
      } else {
        output = os.wrapSingleIdentifier(iden, output);
      }
    } else {
      buffer.length = 0;
      buffer.push(os.wrapSingleIdentifier(parts[0], output));
      for (var j = 1; j < parts.length; j+= 3) {
        buffer.push(parts[j]);
        if (parts[j + 1]) {
          buffer.push(os.wrapIdentifiersInExpression(parts[j + 1]));
        }
        buffer.push(parts[j + 2]);
      }
      output = buffer.join('');
    }
  }
 return output;
};

/**
 * Wraps all identifiers in a JS expression. The expression is tokenized, then
 * each token is wrapped individually.
 * @param {string} expr The expression to wrap.
 * @param {string} opt_default An optional default value reference (such as the
 * literal string 'null').
 */
os.wrapIdentifiersInExpression = function(expr, opt_default) {
  var out = [];
  var tokens = os.expressionToTokens(expr);
  for (var i = 0; i < tokens.length; i++) {
    out.push(os.wrapIdentifiersInToken(tokens[i], opt_default));
  }
  return out.join('');
};

/**
 * Tokenizes a JS expression. Each token is either an operator, a literal
 * string, an identifier, or a function call.
 * For example,
 *   "foo||bar" is tokenized as ["foo", "||", "bar"], but
 *   "bing(foo||bar)" becomes   ["bing(foo||bar)"].
 */
os.expressionToTokens = function(expr) {
  var tokens = [];
  var inquotes = false;
  var inidentifier = false;
  var inparens = 0;
  var escaped = false;
  var quotestart = null;
  var buffer = [];
  for (var i = 0; i < expr.length; i++) {
    var ch = expr.charAt(i);
    if (inquotes) {
      if (!escaped && ch == quotestart) {
        inquotes = false;
      } else if (ch == '\\') {
        escaped = true;
      } else {
        escaped = false;
      }
      buffer.push(ch);
    } else {
      if (ch == "'" || ch == '"') {
        inquotes = true;
        quotestart = ch;
        buffer.push(ch);
        continue;
      }
      if (ch == '(') {
        inparens++;
      } else if (ch == ')' && inparens > 0) {
        inparens--;
      }
      if (inparens > 0) {
        buffer.push(ch);
        continue;
      }
      if (!inidentifier && os.canStartIdentifier(ch)) {
        if (buffer.length > 0) {
          tokens.push(buffer.join(''));
          buffer.length = 0;
        }
        inidentifier = true;
        buffer.push(ch);
        continue;
      }
      if (inidentifier) {
        if (os.canBeInToken(ch)) {
          buffer.push(ch);
        } else {
          tokens.push(buffer.join(''));
          buffer.length = 0;
          inidentifier = false;
          buffer.push(ch);
        }
      } else {
        buffer.push(ch);
      }
    }
  }
  tokens.push(buffer.join(''));
  return tokens;
};

/**
 * Breaks up a JS token into identifiers, separated by '.'
 * "foo.bar" becomes ["foo", "bar"].
 */
os.tokenToIdentifiers = function(token) {
  var inquotes = false;
  var quotestart = null;
  var escaped = false;
  var buffer = [];
  var identifiers = [];
  for (var i = 0; i < token.length; i++) {
    var ch = token.charAt(i);
    if (inquotes) {
      if (!escaped && ch == quotestart) {
        inquotes = false;
      } else if (ch == '\\') {
        escaped = true;
      } else {
        escaped = false;
      }
      buffer.push(ch);
      continue;
    } else {
      if (ch == "'" || ch == '"') {
        buffer.push(ch);
        inquotes = true;
        quotestart = ch;
        continue;
      }
    }
    if (ch == '.' && !inquotes) {
      identifiers.push(buffer.join(''));
      buffer.length = 0;
      continue;
    }
    buffer.push(ch);
  }
  identifiers.push(buffer.join(''));
  return identifiers;
};

/**
 * Checks if a JS identifier has parenthesis and bracket parts. If no such
 * parts are found, return false. Otherwise, the expression is returned as
 * an array of components:
 *   "foo(bar)"       -> ["foo", "(", "bar", ")"]
 *   "foo[bar](baz)"  -> ["foo", "[", "bar", "]", "(", "baz", ")"]
 */
os.breakUpParens = function(identifier) {
  var parenIndex = identifier.indexOf('(');
  var bracketIndex = identifier.indexOf('[');
  if (parenIndex < 0 && bracketIndex < 0) {
    return false;
  }
  var parts = [];
  if (parenIndex < 0 || (bracketIndex >= 0 && bracketIndex < parenIndex)) {
    parenIndex = 0;
    parts.push(identifier.substring(0, bracketIndex));
  } else {
    bracketIndex = 0;
    parts.push(identifier.substring(0, parenIndex));
  }
  var parenstart = null;
  var inquotes = false;
  var quotestart = null;
  var parenlevel = 0;
  var escaped = false;
  var buffer = [];
  for (var i = bracketIndex + parenIndex; i < identifier.length; i++) {
    var ch = identifier.charAt(i);
    if (inquotes) {
      if (!escaped && ch == quotestart) {
        inquotes = false;
      } else if (ch == '\\') {
        escaped = true;
      } else {
        escaped = false;
      }
      buffer.push(ch);
    } else {
      if (ch == "'" || ch == '"') {
        inquotes = true;
        quotestart = ch;
        buffer.push(ch);
        continue;
      }
      if (parenlevel == 0) {
        if (ch == '(' || ch == '[') {
          parenstart = ch;
          parenlevel++;
          parts.push(ch);
          buffer.length = 0;
        }
      } else {
        if ((parenstart == '(' && ch == ')') ||
          (parenstart == '[' && ch == ']')) {
          parenlevel--;
          if (parenlevel == 0) {
            parts.push(buffer.join(''));
            parts.push(ch);
          } else {
            buffer.push(ch);
          }
        } else {
          if (ch == parenstart) {
            parenlevel++;
          }
          buffer.push(ch);
        }
      }
    }
  }
  return parts;
};

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
/**
 * @fileoverview Provides the Template class used to represent a single
 * compiled template that can be rendered into any DOM node.
 */


/**
 * Creates a context object out of a json data object.
 */
os.createContext = function(data, opt_globals) {
  var context = JsEvalContext.create(data);
//  context.setVariable(os.VAR_callbacks, []);
//  var defaults = os.getContextDefaults_();
//  for (var def in defaults) {
//    if (defaults.hasOwnProperty(def)) {
//      context.setVariable(def, defaults[def]);
//    }
//  }
    context.setVariable(os.VAR_emptyArray, os.EMPTY_ARRAY);
context.setVariable(os.VAR_identifierresolver, os.getFromContext);
//  if (opt_globals) {
//    for (var global in opt_globals) {
//      if (opt_globals.hasOwnproperty(global)) {
//        context.setVariable(global, opt_globals[global]);
//      }
//    }
//  }
  return context;
};

//os.contextDefaults_ = null;

//os.getContextDefaults_ = function() {
//  if (!os.contextDefaults_) {
//    os.contextDefaults_ = {};
//    os.contextDefaults_[os.VAR_emptyArray] = os.EMPTY_ARRAY;
//    os.contextDefaults_[os.VAR_identifierresolver] = os.getFromContext;
//    if (window["JSON"] && JSON.parse) {
//      os.contextDefaults_["osx:parseJson"] = JSON.parse;
//    } else if (window["gadgets"] && gadgets.json && gadgets.json.parse) {
//      os.contextDefaults_["osx:parseJson"] = gadgets.json.parse;
//    }
//  }
//  return os.contextDefaults_;
//};

/**
 * A renderable compiled Template. A template can contain one or more
 * compiled nodes pre-processed for JST operation. 
 * @constructor
 */
//os.Template = function(opt_id) {
//  this.templateRoot_ = document.createElement("span");
//  this.id = opt_id || ('template_' + os.Template.idCounter_++);
//};

/**
 * A global counter for template IDs.
 * @type {number}
 * @private
 */
//os.Template.idCounter_ = 0;

/**
 * A Map of registered templates by keyed ID.
 * @type {Object.<string, os.Template>}
 * @private 
 */
//os.registeredTemplates_ = {};

/**
 * Registers a compiled template by its ID.
 * @param {os.Template} template List of template nodes.
 */
//os.registerTemplate = function(template) {
//  os.registeredTemplates_[template.id] = template;
//};

/**
 * De-registers a compiled template..
 * @param {os.Template} template List of template nodes.
 */
//os.unRegisterTemplate = function(template) {
//  delete os.registeredTemplates_[template.id];
//};

/**
 * Gets a registered template by ID.
 * @param {string} templateId The ID of a registered Template.
 * @return {os.Template} A Template object.
 */
//os.getTemplate = function(templateId) {
//  return os.registeredTemplates_[templateId];
//};

/**
 * Sets a single compiled node into this template.
 * @param node {Element} A compiled node.
 */
//os.Template.prototype.setCompiledNode_ = function(node) {
//  os.removeChildren(this.templateRoot_);
//  this.templateRoot_.appendChild(node);
//};

/**
 * Sets a list of compiled nodes into this template.
 * @param nodes {Array.Element} An array of compiled nodes.
 */
//os.Template.prototype.setCompiledNodes_ = function(nodes) {
//  os.removeChildren(this.templateRoot_);
//  for (var i = 0; i < nodes.length; i++) {
//    this.templateRoot_.appendChild(nodes[i]);
//  }
//};

/**
 * Renders the template and returns the result.
 * Does not fire callbacks.
 * @return {Element} a DOM element containing the result of template processing
 */
//os.Template.prototype.render = function(opt_data, opt_context) {
//  if (!opt_context) {
//    opt_context = os.createContext(opt_data);
//  }
//  return os.renderTemplateNode_(this.templateRoot_, opt_context);            
//};

/**
 * Renders the template and puts the result into the specified element, then
 * fires callbacks.
 */
//os.Template.prototype.renderInto = function(root, opt_data, opt_context) {
//  if (!opt_context) {
//    opt_context = os.createContext(opt_data);
//  }
//  var result = this.render(opt_data, opt_context);
//  os.removeChildren(root);
//  os.appendChildren(result, root);
//  os.fireCallbacks(opt_context);
//};

} // if (!window.os) {
